Unity Manual

Welcome to Unity.

Unity is made to empower you to create the best interactive entertainment or multimedia experience that you can. This manual is designed to help you learn how to use Unity, from basic to advanced techniques. It can be read from start to finish or used as a reference.

The manual is divided into different sections. The first section, User Guide, is an introduction to Unity's interface, asset workflow, and the basics of building a game. If you are new to Unity, you should start by reading the Unity Basics subsection.

The next section, FAQ, is a collection of frequently asked questions about performing common tasks that require a few steps.

The last section, Advanced, addresses topics such as game optimization, shaders, file sizes, and deployment.

When you've finished reading, take a look at the Reference Manual and the Scripting Reference for further details about the different possibilities of constructing your games with Unity.

If you find that any question you have is not answered in this manual please ask on Unity Answers or Unity Forums. You will be able to find your answer there.

Happy reading,
The Unity team

The Unity Manual Guide contains some sections that apply only to certain platforms. Please select which platforms you want to see. Platform-specific information can always be seen by clicking on the disclosure triangles on each page.

Page last updated: 2012-11-16

User Guide

This section of the Manual is focused on the features and functions of Unity. It discusses the interface, core Unity building blocks, asset workflow, and basic gameplay creation. By the time you are done reading the user guide, you will have a solid understanding of how to use Unity to put together an interactive scene and publish it.

We recommend that new users begin by reading the Unity Basics section.

• Unity Basics
  • インターフェースについての学習
    • Project Browser
    • Hierarchy
    • Toolbar
    • Scene View
    • Game View
    • Inspector
    • Other Views
  • Customizing Your Workspace
  • Asset Workflow
  • シーンの作成
  • ビルドの公開
  • チュートリアル
  • Unity Hotkeys
  • Preferences
• Building Scenes
  • GameObject
    • The GameObject-Component Relationship
    • Using Components
    • コンポーネントとスクリプトの関係
    • Deactivating GameObjects
  • Using the Inspector
    • Editing Value Properties
    • リファレンスの割り当て
    • Multi-Object Editing
    • インスペクタ オプション
  • Using the Scene View
    • Scene View Navigation
    • GameObjects の配置
    • View Modes
    • Gizmo and Icon Display Controls
  • Searching
  • Prefabs
  • ライト
  • Cameras
  • Terrain Engineガイド
• Asset Import and Creation
  • Importing Assets
  • Mesh
    • 3Dフォーマット
  • Animations (Legacy)
  • Materials and Shaders
  • Textures
  • Procedural Materials
  • Movie Textures
  • Audio Files
    • Tracker Modules
  • Using Scripts
  • Asset Store
  • Asset Server (Pro Only)
    • Cache Server (Team license only)
    • Cache Server FAQ
  • Behind the Scenes
• ゲームプレイの作成
  • Instantiating Prefabs at runtime
  • Input
  • Transforms
  • Physics
  • Adding Random Gameplay Elements
  • Particle Systems
    • パーティクルシステムCurve Editor
    • パーティクルシステムの色およびグラデーション（Shuriken）
    • Gradient Editor
    • Particle System Inspector
    • Introduction to Particle System Modules (Shuriken)
    • Particle System Modules (Shuriken)
    • Particle Effects (Shuriken)
  • Mecanim Animation System
    • A Glossary of Animation and Mecanim terms
    • Asset Preparation and Import
      • Preparing your own character
      • Importing Animations
      • Splitting Animations
    • Working with humanoid animations
      • Avatar作成
      • Configuring the Avatar
      • Muscle setup
      • Avatar Body Mask
      • Retargeting of Humanoid animations
      • Inverse Kinematics (Pro only)
    • Generic Animations in Mecanim
    • Bringing characters to life
      • Looping animation clips
      • Animator Component and Animator Controller
      • Animation State Machines
        • Animation States
        • Animation Transitions
        • Animation Parameters
      • Blend Trees
      • Mecanim Advanced topics:
        • Working with Animation Curves in Mecanim (Pro only)
        • Nested State Machines
        • Animation Layers
        • Animation State Machine Preview (solo and mute)
        • Target Matching
        • Root Motion - how it works
          • Manually Scripting Root Motion
  • Animations (Legacy)
    • Animation View Guide (Legacy)
    • Animation Scripting (Legacy)
  • Navmesh and Pathfinding (Pro only)
    • Navmesh Baking
  • Sound
  • Game Interface Elements
  • Networked Multiplayer

Unity Basics

This section is your key to getting started with Unity. It will explain the Unity interface, menu items, using assets, creating scenes, and publishing builds.

When you are finished reading this section, you will understand how Unity works, how to use it effectively, and the steps to put a basic game together.

Learning the Interface There is a lot to learn, so take the time you need to observe and understand the interface. We will walk through each interface element together.   Asset Workflow Here we'll explain the steps to use a single asset with Unity. These steps are general and are meant only as an overview for basic actions.   Creating Scenes Scenes contain the objects of your game. In each Scene, you will place your environments, obstacles, and decorations, designing and building your game in pieces.

Publishing Builds At any time while you are creating your game, you might want to see how it looks when you build and run it outside of the editor as a standalone or web player. This section will explain how to access the Build Settings and how to create different builds of your games.   Tutorials These online tutorials will let you work with Unity while you follow along, providing hands-on experience with building real projects.

Learning the Interface

Unityエディタのインターフェースについての概要を見て、まずはそれに慣れていただきます。メインとなるエディタウィンドウ はいくつかの タブウィンドウ （ビュー(View) と呼ばれます）から構成されています。Unityには様々なタイプのビューがあり、それらは全て以下の項目にあるような特定の目的を持っています。

• Project Browser
• Hierarchy
• Toolbar
• Scene View
• Game View
• Inspector
• Other Views

ProjectView40

In this view, you can access and manage the assets that belong to your project.

The left panel of the browser shows the folder structure of the project as a hierarchical list. When a folder is selected from the list by clicking, its contents will be shown in the panel to the right. The individual assets are shown as icons that indicate their type (script, material, sub-folder, etc). The icons can be resized using the slider at the bottom of the panel; they will be replaced by a hierarchical list view if the slider is moved to the extreme left. The space to the left of the slider shows the currently selected item, including a full path to the item if a search is being performed.

Above the project structure list is a Favorites section where you can keep frequently-used items for easy access. You can drag items from the project structure list to the Favourites and also save search queries there (see Searching below).

Just above the panel is a "breadcrumb trail" that shows the path to the folder currently being viewed. The separate elements of the trail can be clicked for easy navigation around the folder hierarchy. When searching, this bar changes to show the area being searched (the root Assets folder, the selected folder or the Asset Store) along with a count of free and paid assets available in the store, separated by a slash. There is an option in the General section of Unity's Preferences window to disable the display of Asset Store hit counts if they are not required.

Along the top edge of the window is the browser's toolbar.

Located at the left side of the toolbar, the Create menu lets you add new assets and sub-folders to the current folder. To its right are a set of tools to allow you to search the assets in your project.

The Window menu provides the option of switching to a one-column version of the project view, essentially just the hierarchical structure list without the icon view. The lock icon next to the menu enables you to "freeze" the current contents of the view (ie, stop them being changed by events elsewhere) in a similar manner to the inspector lock.

Searching

The browser has a powerful search facility that is especially useful for locating assets in large or unfamiliar projects. The basic search will filter assets according to the text typed in the search box

If you type more than one search term then the search is narrowed, so if you type coastal scene it will only find assets with both "coastal" and "scene" in the name (ie, terms are ANDed together).

To the right of the search bar are three buttons. The first allows you to further filter the assets found by the search according to their type.

Continuing to the right, the next button filters assets according to their Label (labels can be set for an asset in the Inspector). Since the number of labels can potentially be very large, the label menu has its own mini-search filter box.

Note that the filters work by adding an extra term in the search text. A term beginning with "t:" filters by the specified asset type, while "l:" filters by label. You can type these terms directly into the search box rather than use the menu if you know what you are looking for. You can search for more than one type or label at once. Adding several types will expand the search to include all specified types (ie, types will be ORed together). Adding multiple labels will narrow the search to items that have all the specified labels (ie, labels are ANDed).

The rightmost button saves the search by adding an item to the Favourites section of the asset list.

Searching the Asset Store

The Project Browser's search can also be applied to assets available from the Unity Asset Store. If you choose Asset Store from the menu in the breadcrumb bar, all free and paid items from the store that match your query will be displayed. Searching by type and label works the same as for a Unity project. The search query words will be checked against the asset name first and then the package name, package label and package description in that order (so an item whose name contains the search terms will be ranked higher than one with the same terms in its package description).

If you select an item from the list, its details will be displayed in the inspector along with the option to purchase and/or download it. Some asset types have previews available in this section so you can, for example, play an audio clip or rotate a 3D model before buying. The inspector also gives the option of viewing the asset in the usual Asset Store window to see additional details.

Shortcuts

The following keyboard shortcuts are available when the browser view has focus. Note that some of them only work when the view is using the two-column layout (you can switch between the one- and two-column layouts using the panel menu in the very top right corner).

Hierarchy

The Hierarchy contains every GameObject in the current Scene. Some of these are direct instances of asset files like 3D models, and others are instances of Prefabs, custom objects that will make up much of your game. You can select objects in the Hierarchy and drag one object onto another to make use of Parenting (see below). As objects are added and removed in the scene, they will appear and disappear from the Hierarchy as well.

Parenting

Unity uses a concept called Parenting. To make any GameObject the child of another, drag the desired child onto the desired parent in the Hierarchy. A child will inherit the movement and rotation of its parent. You can use a parent object's foldout arrow to show or hide its children as necessary.

Two unparented objects

One object parented to another

To learn more about Parenting, please review the Parenting section of the Transform Component page.

Toolbar

The Toolbar consists of five basic controls. Each relate to different parts of the Editor.

Transform Tools -- used with the Scene View
Transform Gizmo Toggles -- affect the Scene View display
Play/Pause/Step Buttons -- used with the Game View
Layers Drop-down -- controls which objects are displayed in Scene View
Layout Drop-down -- controls arrangement of all Views

SceneView40

The Scene View

The Scene View is your interactive sandbox. You will use the Scene View to select and position environments, the player, the camera, enemies, and all other GameObjects. Maneuvering and manipulating objects within the Scene View are some of the most important functions in Unity, so it's important to be able to do them quickly. To this end, Unity provides keystrokes for the most common operations.

Scene View Navigation

See Scene View Navigation for full details on navigating the scene view. Here's a brief overview of the essentials:

• Hold the right mouse button to enter Flythrough mode. This turns your mouse and WASD keys (plus Q and E for up and down) into quick first-person view navigation.
• Select any GameObject and press the F key. This will center the Scene View and pivot point on the selection.
• Use the arrow keys to move around on the X/Z plane.
• Hold Alt and click-drag to orbit the camera around the current pivot point.
• Hold Alt and middle click-drag to drag the Scene View camera around.
• Hold Alt and right click-drag to zoom the Scene View. This is the same as scrolling with your mouse wheel.

You might also find use in the Hand Tool (shortcut: Q), especially if you are using a one-button mouse. With the Hand tool is selected,

Click-drag to drag the camera around.
Hold Alt and click-drag to orbit the camera around the current pivot point.
Hold Control (Command on Mac) and click-drag to zoom the camera.

In the upper-right corner of the Scene View is the Scene Gizmo. This displays the Scene Camera's current orientation, and allows you to quickly modify the viewing angle.

Each of the coloured "arms" of the gizmo represents a geometric axis. You can click on any of the arms to set the camera to an orthographic (i.e., perspective-free) view looking along the corresponding axis. You can click on the text underneath the gizmo to switch between the normal perspective view and an isometric view. While in isometric mode, you can right-click drag to orbit, and Alt-click drag to pan.

Positioning GameObjects

See Positioning GameObjects for full details on positioning GameObjects in the scene. Here's a brief overview of the essentials:

When building your games, you'll place lots of different objects in your game world. To do this use the Transform Tools in the Toolbar to Translate, Rotate, and Scale individual GameObjects. Each has a corresponding Gizmo that appears around the selected GameObject in the Scene View. You can use the mouse and manipulate any Gizmo axis to alter the Transform Component of the GameObject, or you can type values directly into the number fields of the Transform Component in the Inspector.

Scene View Control Bar

The Scene View control bar lets you see the scene in various view modes - Textured, Wireframe, RGB, Overdraw, and many others. It will also enable you to see (and hear) in-game lighting, game elements, and sound in the Scene View. See View Modes for all the details.

GameView40

Game Viewはゲーム内のCameraから見た絵をレンダリングしています。それはあなたが最終的に出力しようとしているゲーム画面です。あなたのゲームをしている時に、プレイヤーが今何を見ているかをコントロールするために　あなたは１個以上のCameraを使う必要があります。Cameraの詳細については、Camera Component page をご覧ください

Play Mode

エディター上のツールバーのPlay Modeボタンを押すと、ゲームが再生されます。再生モード中にあなたが行った変更は一時的なもので、再生モードを終了するときにリセットされます。変更が一時的なものだということを忘れないように、エディタのUIは暗くなります。

Game Viewコントロールバー

Game Viewコントロールバーの最初のドロップダウンメニューがAspect ドロップダウンです。ここでは、Game Viewウィンドウのアスペクト比を異なる値に強制することができます。それはあなたのゲームが異なる縦横比のモニターでどのように見えるかテストするために利用できます。

さらに右に行くと Maximize on Play トグルです. 有効になっているときに再生モードに入ると、Game Viewは素晴らしいフルスクリーンプレビューのためのあなたのエディタウィンドウの100％に自分自身を最大化します。

続けて右にあるのが Stats ボタンです。 これは、レンダリングの統計情報 ​​あなたのゲームのグラフィックス性能を監視するために非常に有用であるウィンドウを表示させるものです。（ Optimizing Graphics Performance の詳細を参照してください）

最後のボタンは Gizmos トグルです。有効になっている間、シーンビューに表示されるすべてのギズモがGame Viewで描画されます。これはGizmosクラス関数で使われる全てのギズモが含まれます。ギズモボタンを押すとポップアップメニューが出てきて、ゲームで使用される部品の様々な異なる種類のコンポーネントを表示／非表示が可能です。

各コンポーネント名の横にあるアイコンと、それに関連するギズモの設定値は以下のとおりです。アイコンの設定でまた別のポップアップメニューが表示されます。そのポップアップはプリセットアイコンやテクスチャで定義されたカスタムアイコンのどちらかを選ぶことができます。

Gizmo設定で選択した特定のコンポーネントに対してギズモ描画を無効にすることができます。

メニューの一番上の3D Gizmos設定は、ギズモのアイコンについてのものです。設定を有効にすると、アイコンがCameraに対してパースペクティブになり（すなわち、近くのオブジェクトのアイコンは遠くのオブジェクト用のものよりも大きくなります）、逆だと距離に関係なく同じ大きさになります。チェックボックスの横にあるスライダーを使用すると、アイコンのサイズを変化させることができます。これは目に見えるギズモがたくさんあるときに混乱を避けるために便利です。

Inspector

Games in Unity are made up of multiple GameObjects that contain meshes, scripts, sounds, or other graphical elements like Lights. The Inspector displays detailed information about your currently selected GameObject, including all attached Components and their properties. Here, you modify the functionality of GameObjects in your scene. You can read more about the GameObject-Component relationship, as it is very important to understand.

Any property that is displayed in the Inspector can be directly modified. Even script variables can be changed without modifying the script itself. You can use the Inspector to change variables at runtime to experiment and find the magic gameplay for your game. In a script, if you define a public variable of an object type (like GameObject or Transform), you can drag and drop a GameObject or Prefab into the Inspector to make the assignment.

Click the question mark beside any Component name in the Inspector to load its Component Reference page. Please view the Component Reference for a complete and detailed guide to all of Unity's Components.

Add Components from the Component menu

You can click the tiny gear icon (or right-click the Component name) to bring up a context menu for the specific Component.

The Inspector will also show any Import Settings for a selected asset file.

Click Apply to reimport your asset.

Use the Layer drop-down to assign a rendering Layer to the GameObject. Use the Tag drop-down to assign a Tag to this GameObject.

Prefabs

If you have a Prefab selected, some additional buttons will be available in the Inspector. For more information about Prefabs, please view the Prefab manual page.

Labels

Unity allows assets to be marked with Labels to make them easier to locate and categorise. The bottom item on the inspector is the Asset Labels panel.

Attach:InspectorLabelsPanelEmpty.png Δ

At the bottom right of this panel is a button titled with an ellipsis ("...") character. Clicking this button will bring up a menu of available labels

Attach:InspectorLabelsMenu.png Δ

You can select one or more items from the labels menu to mark the asset with those labels (they will also appear in the Labels panel). If you click a second time on one of the active labels, it will be removed from the asset.

Attach:InspectorAssetMenuWithLabels.png Δ

The menu also has a text box that you can use to specify a search filter for the labels in the menu. If you type a label name that does not yet exist and press return/enter, the new label will be added to the list and applied to the selected asset. If you remove a custom label from all assets in the project, it will disappear from the list.

Once you have applied labels to your assets, you can use them to refine searches in the Project Browser (see this page for further details). You can also access an asset's labels from an editor script using the AssetDatabase class.

Other Views

The Views described on this page covers the basics of the interface in Unity. The other Views in Unity are described elsewhere on separate pages:

• The Console shows logs of messages, warnings, and errors.
• The Animation View can be used to animate objects in the scene.
• The Profiler can be used to investigate and find the performance bottle-necks in your game.
• The Asset Server View can be used to manage version control of the project using Unity's Asset Server.
• The Lightmapping View can be used to manage lightmaps using Unity's built-in lightmapping.
• The Occlusion Culling View can be used to manage Occlusion Culling for improved performance.

Customizing Your Workspace

ワークスペースのカスタマイズ

いずれかのビューのタブをいくつかの場所にクリック & ドラッグして、ビューの Layout をカスタマイズできます。 既存のウィンドウの Tab Area にタブをドロップすると、既存のタブの脇にタブが追加されます。 また、Dock Zone にタブをドロップすることで、新しいウィンドウにビューを追加します。

「ビューは、既存のウィンドウの両側または下部にドッキングできます」

タブは、メイン エディタ ウィンドウから切り離して、フローティング エディタ ウィンドウに配列できます。 フローティング ウィンドウは、メイン エディタ ウィンドウ同様、ビューとタブの配列を含むことができます。

「フローティング エディタ ウィンドウは、ツールバーがない点を除いては、メイン エディタ ウィンドウを同じです」

エディタ ウィンドウのレイアウトを作成している場合は、レイアウトを保存し、いつでも復旧できます。 これを行うには、レイアウト ドロップダウン (ツールバー上) を展開し、Save Layout... を選択します。 新しいレイアウトに名前を付けて保存し、レイアウト ドロップダウンから選択するだけで復旧できます。

「完全にカスタムのレイアウト」

いつでも、ビューのタブを右クリックして、最大化などのオプションを表示したり、同じウィンドウに新しいタブを追加したりできます。

Asset Workflow

Here we'll explain the steps to use a single asset with Unity. These steps are general and are meant only as an overview for basic actions. For the example, we'll talk about using a 3D mesh.

Create Rough Asset

Use any supported 3D modeling package to create a rough version of your asset. Our example will use Maya. Work with the asset until you are ready to save. For a list of applications that are supported by Unity, please see this page.

Import

When you save your asset initially, you should save it normally to the Assets folder in your Project folder. When you open the Unity project, the asset will be detected and imported into the project. When you look in the Project View, you'll see the asset located there, right where you saved it. Please note that Unity uses the FBX exporter provided by your modeling package to convert your models to the FBX file format. You will need to have the FBX exporter of your modeling package available for Unity to use. Alternatively, you can directly export as FBX from your application and save in the Projects folder. For a list of applications that are supported by Unity, please see this page.

Import Settings

If you select the asset in the Project View the import settings for this asset will appear in the Inspector. The options that are displayed will change based on the type of asset that is selected.

Adding Asset to the Scene

Simply click and drag the mesh from the Project View to the Hierarchy or Scene View to add it to the Scene. When you drag a mesh to the scene, you are creating a GameObject that has a Mesh Renderer Component. If you are working with a texture or a sound file, you will have to add it to a GameObject that already exists in the Scene or Project.

Putting Different Assets Together

Here is a brief description of the relationships between the most common assets

• A Texture is applied to a Material
• A Material is applied to a GameObject (with a Mesh Renderer Component)
• An Animation is applied to a GameObject (with an Animation Component)
• A sound file is applied to a GameObject (with an Audio Source Component)

Creating a Prefab

Prefabs are a collection of GameObjects & Components that can be re-used in your scenes. Several identical objects can be created from a single Prefab, called instancing. Take trees for example. Creating a tree Prefab will allow you to instance several identical trees and place them in your scene. Because the trees are all linked to the Prefab, any changes that are made to the Prefab will automatically be applied to all tree instances. So if you want to change the mesh, material, or anything else, you just make the change once in the Prefab and all the other trees inherit the change. You can also make changes to an instance, and choose GameObject->Apply Changes to Prefab from the main menu. This can save you lots of time during setup and updating of assets.

When you have a GameObject that contains multiple Components and a hierarchy of child GameObjects, you can make a Prefab of the top-level GameObject (or root), and re-use the entire collection of GameObjects.

Think of a Prefab as a blueprint for a structure of GameObjects. All the Prefab clones are identical to the blueprint. Therefore, if the blueprint is updated, so are all the clones. There are different ways you can update the Prefab itself by changing one of its clones and applying those changes to the blueprint. To read more about using and updating Prefabs, please view the Prefabs page.

To actually create a Prefab from a GameObject in your scene, simply drag the GameObject from the scene into the project, and you should see the Game Object's name text turn blue. Name the new Prefab whatever you like. You have now created a re-usable prefab.

Updating Assets

You have imported, instantiated, and linked your asset to a Prefab. Now when you want to edit your source asset, just double-click it from the Project View. The appropriate application will launch, and you can make any changes you want. When you're done updating it, just Save it. Then, when you switch back to Unity, the update will be detected, and the asset will be re-imported. The asset's link to the Prefab will also be maintained. So the effect you will see is that your Prefab will update. That's all you have to know to update assets. Just open it and save!

Optional - Adding Labels to the Assets.

Is always a good idea to add labels to your assets if you want to keep organized all your assets, with this you can search for the labels associated to each asset in the search field in the project view or in the object selector.

Steps for adding a label to an asset:

• Select the asset you want to add the label to (From the project view).
• In the inspector click on the "Add Label" icon () if you dont have any Labels associated to that asset.
  • If you have a label associated to an asset then just click where the labels are.
• Start writing your labels.

Notes:

• You can have more than one label for any asset.
• To separate/create labels, just press space or enter when writing asset label names.

Creating Scenes

Scenes には、ゲームのオブジェクトが含まれています。 シーンを使用して、メイン メニュー、個々のレベルなどを作成できます。 1 つのシーン ファイルは 1 つのレベルとして考えてください。 各シーンでは、環境や障害物、装飾を配置し、主にゲームを細かく設計および作成します。

プレハブのインスタンス化

最後の項で説明する方法で Prefab を作成します。 プレハブの詳細については、here を参照してください。 プレハブを作成したら、Instance と呼ばれるプレハブのコピーを素早く、簡単に作成できます。 プレハブのインスタンスを作成するには、Project View から、Hierarchy または Scene View にプレハブをドラッグします。 今度は、プレハブの 1 つだけのインスタンスを自由に配置し、微調整します。

コンポーネントとスクリプトの追加

プレハブや GameObject を強調表示すると、Components を使用して、機能をさらに追加できます。 各種コンポーネントの詳細については、Component Reference を参照してください。 Scripts は、コンポーネントの一種です。 コンポーネントを追加するには、GameObject を強調表示し、Component メニューからコンポーネントを選択します。 コンポーネントが GameComponent の Inspector に表示されます。 スクリプトは、デフォルトで、Component メニューにも含まれます。

コンポーネントの追加により、そのプレハブへの GameObject の接続が壊れる場合は、リンクを再構築するため、常にメニューから GameObject->Apply Changes to Prefab を使用できます。

GameObject の設置

GameObject をシーン内に置くと、Transform Tools を使用して、好きな時に配置できます。 さらに、インスペクタで「Transform」値を使用して、配置と回転を微調整できます。 GameObject の配置および回転の詳細については、Transform Component page ページを参照してください。

カメラの取り扱い

Cameras はゲームの眼です。 プレイ時にプレイヤーが目にするものはすべて、1 つまたは複数のカメラを通じて得られます。 その他の GameObject 同様、カメラは配置、回転、親子関係の構築を行うことができます。 カメラは、カメラ 今後が追加されたカメラ コンポーネントのある　GameObject にすぎません。 そのため、通常の GameObject ができることの他、カメラ固有の機能も行うことができます。 新しいプロジェクト作成時に標準のアセットと共にインストールされる便利なカメラ スクリプトがあります。 これは、メニューから Components->Camera-Control を選択すると使用できます。 理解すべきカメラに追加される側面が幾つかあります。 カメラについては、Camera Component reference を参照してください。

ライト

非常に稀なケースを除いて、シーンに必ず Lights を追加する必要があります。 ライトには 3 種類あり、そのすべての動作がそれぞれ若干異なります。 重要なことは、ライトは、ゲームにムードや雰囲気を加えることができます。 照明が変わると、ゲームのムードも完全に代わり、ライトの活用は学ぶべき重要な主題になります。 カメラについては、Camera Component reference を参照してください。

Publishing Builds

ゲーム作成中、ゲームを作成し、スタンドアロンまたはウェブ プレイヤーとして、エディタの外部で実行する際、常時どのように見えるかを確認したい場合があるでしょう。 本項では、Build Settings へのアクセス方法およびゲームの各種ビルドの作成方法について説明します。

File->Build Settings... は、ビルド設定ウィンドウにアクセスするためのメニュー項目です。 ゲーム作成時に含まれるシーンの編集可能なリストがポップアップ表示されます。

ビルド設定ウィンドウ

最初にプロジェクトでこのウィンドウを開くと、空に見えます。 このリストが空のままで、ゲームを作成すると、現在開いているシーンのみがビルドに含まれます。 1 つのシーン ファイルだけでテスト プレイヤーを素早く作成したい場合は、空のシーン リストでプレイヤーを作成します。

マルチシーンビルドでこのリストにシーン ファイルを追加するのは簡単です。 次の 2 種類の追加方法があります。 まず、Add Current ボタンをクリックします。 リストに現在開いているシーンが表示されます。 次に、シーン ファイルを追加するには、 Project View からリストにファイルをドラッグします。

この時点までに、シーンによってインデックス値が異なります。 Scene 0 は、ゲーム ビルド時にロードサれる最初のシーンです。 新しいシーンをロードするには、スクリプト内で Application.LoadLevel() を使用します。

複数のシーン ファイルを追加し、最配置したい場合、希望の順序になるまで、上記のリストまたは下記のその他でシーンをクリックし、ドラッグするだけです。

リストからシーンを削除したい場合は、クリックしてシーンを強調表示し、Command-Delete を押します。 リストからシーンが消え、ビルドに含まれなくなります。

ビルドをパブリッシュする準備ができたら、Platform を選択し、Unity のロゴがプラットフォームの隣にあるか確認します。ない場合は、Switch Platform ボタンをクリックして、Unity に作成したいプラットフォームを知らせます。 最後に、Build ボタンを押します。 標準の保存ダイアログを使用して、ゲームに名前と位置を選択できるようになります。 Save をクリックすると、Unity がゲームをすぐに作成します。 これは非常にシンプルです。 作成したゲームをどこに保存すべきか分からない場合は、プロジェクトのルート フォルダに保存することを検討してください。 Assets フォルダにはビルドを保存できません。

スタンドアロン プレイヤーで Debug build チェックボックスを有効にすると、Profiler 機能が有効になります。 また、プレイヤーはデバッグ記号で作成されるため、サード パーティプロファイリングまたはデバッギング ツールを使用できます。 Enabling the Development Build checkbox on a player will enable Profiler functionality and also make the Autoconnect Profiler and Script Debugging options available.

Desktop

Application.LoadLevel("levelName");

var levelToLoad = 1;

function LoadNewLevel () {
	if (Application.CanStreamedLevelBeLoaded (levelToLoad)) {
		Application.LoadLevel (levelToLoad);
	}
}

iOS

Android

Android アプリケーション ビルド処理には、次の 2 つの手順があります。

1. アプリケーション パッケージ (.apk ファイル) が必要なすべてのライブラリ、プレコンパイルされた .NET コードおよび直列化されたアセットと共に生成されます。
2. アプリケーション パッケージが作成され、実機に配備されます。

ビルド設定ダイアログで作成を押すと、最初の手順のみ達成されます。 ディタで作成と実行を押すと、両方の手順が行われます。 Cmd+B を押すと、自動作成および実行処理が呼び出され、最新の使用されたフォルダがビルド対象とみなされます。

最初に Android プロジェクトを作成する際に、Unity によって Android SDK を置くように求められます。これは、機器に Android アプリケーションを作成し、インストールするのに必要になります。 この設定は、Preferences で後で変更できます。

Android にアプリケーションを作成する際、機器設定で、USB DebuggingおよびAllow mock locationsチェックボックスにチェックが入っていることを確認してください。

Android SDK/platform-tools フォルダにある adb devices コマンドを実行することで、OS は機器を確認できます。 これは、Windows と Mac プロジェクト ファイルの両方に機能します。

Unity は、アプリケーション アーカイブ (.apk ファイル) を作成し、接続された機器にインストールします。 アプリケーションが、iPhone 上などで自動起動できない場合があるため、画面のロックを解除する必要があります。新たにインストールされたアプリケーションがメニューに表示される場合も稀にあります。

テクスチャ圧縮

Build Settings 下に、Texture Compression オプションがあります。 デフォルトでは、Unity は、個々のテクスチャ形式の無効のないテクスチャに対しては、[ Main.android-GettingStarted | ETC1/RGBA16 ]] テクスチャ形式を使用します (Texture 2D / Per-Platform Overrides 参照)。

特定のハードウェア アーキテクチャを対象に、アプリケーション アーカイブ (.apk ファイル) を作成したい場合、Texture Compression オプションを使用して、このデフォルトの動作を無効にできます。 圧縮されていないテクスチャはそのままにされます。つまり、圧縮フォーマットのテクスチャだけ Texture Compression オプションで選択されたフォーマットを使います。

アプリケーションが選択したテクスチャ圧縮をサポートしている機器でのみに配備サせたい場合、Unity は、AndroidManifest tを編集して、選択した特定の形式に一致するタグを含めることができます。 これにより、Android Market のフィルタリング機構が、適切なグラフィック ハードウェアを搭載した機器にのみアプリケーションを提供します。

プレロード

パブリッシュされたビルドは、シーンのロード時にシーン内のすべてのアセットを自動的にプレロードします。 このルールの例外は、シーン 0 です。これは、最初のシーンが通常、できるだけ速く表示したいであろうスプラッシュ画面であるためです。

すべての内容がプレロードされるようにするため、Application.LoadLevel(1)を呼び出す空のシーンを作成できます。 ビルド設定で、この空のシーンのインデックスを 0 にします。続くレベルはすべてプレロードされます。

ゲーム作成の準備ができました。

これまで、Unity のインターフェースの使い方、アセットの使い方、シーンの作成法およびビルドのパブリッシュ法を学んできました。 理想のゲーム作成を邪魔するものはありません。 途中更に多くのことを学ぶことになりますが、ここではそのお手伝いをします。

Unity 自体の使用の詳細については、continue reading the manual するか、Tutorials に従ってください。

ゲームの動作の基本であるコンポーネントの詳細については、Component Reference を参照してください。

スクリプティングの詳細については、Scripting Reference を参照してください。

アート アセットの作成の詳細については、本マニュアルの Assets section を参照してください。

Unity ユーザーや開発者のコミュニティに参加したい場合は、Unity Forums にアクセスしてください。 ここでは、質問やプロジェクトの共有、チームの作成などを行えます。あなたの作成した素晴らしいゲームを見たいので、ぜひ 1 度はフォーラムに参加してください。

Tutorials

これらのチュートリアルに従いながら、Unity を使用してください。 実際に体験することで、実際のプロジェクトを作成することができます。 新規ユーザーの場合は、GUI の基本とスクリプティングの基本チュートリアルに その後は、いずれかのチュートリアルに従ってください。 チュートリアルはすべて PDF 形式なので、印刷して、Unity と並行で、指示を仰いだり、参照したりできます。

注意: これらのチュートリアルは、Unity のデスクトップ版向けであるため、Android や iOS 機器 (iPhone/iPad) では機能しません。

また、Unity 向けのプレゼンテーション、アーティクル、アセットまたは拡張などのその他のリソースをお探しの場合は、here から。

また、 Unity3D Tutorial's Home Page をクリックすることで、チュートリアルの最新の追加内容を確認できます。

Unity Hotkeys

このページでは、Unityのデフォルトショートカットキーの概要を説明します。PDFで一覧を確認したい場合は、Windows and MacOSX���らダウンロードできます。。キーの一部に”CTRL/CMD"とある場合は、WindowsではばControlキーをMacOSXならばCommandキーを使用します。

Preferences

Unity provides a number of preference panels to allow you to customise the behaviour of the editor.

General

External Tools

Colors

This panel allows you to choose the colors that Unity uses when displaying various user interface elements.

Keys

This panel allows you to set the keystrokes that activate the various commands in Unity.

Cache Server

Building Scenes

This section will explain the core elements you will work with to build scenes for complete games.

• GameObject
  • The GameObject-Component Relationship
  • Using Components
  • コンポーネントとスクリプトの関係
  • Deactivating GameObjects
• Using the Inspector
  • Editing Value Properties
  • リファレンスの割り当て
  • Multi-Object Editing
  • インスペクタ オプション
• Using the Scene View
  • Scene View Navigation
  • GameObjects の配置
  • View Modes
  • Gizmo and Icon Display Controls
• Searching
• Prefabs
• ライト
• Cameras
• Terrain Engineガイド

GameObjects

GameObjects は、Unity で最も重要なオブジェクトです。 GameObject とは何か、どのように使用できるかを理解することが非常に重要です。 このページでは、そのすべてについて説明します。

GameObject とは何ですか?

ゲーム内のすべてのオブジェクトはすべて本質的に、GameObject になります。 しかし、GameObject は自身では何もしません。 キャラクターや環境、特殊効果になるには、特殊なプロパティが必要です。 これらのオブジェクトはすべて動作が異なります。 すべてのオブジェクトが GameOnject の場合、相互作用パワーアップオブジェクトをスタティック ルームとどのように区別するでしょうか? これらの GameObject を互いに差別化するものは何でしょうか?

この質問の回答は、GameObject は容器です。 これらは空の箱で、ライトマップされた孤島または物理特性駆動の車両を構成する各種ピースを格納できる空の箱です。 そのため、GameObject を本当に理解するには、これらのピースを理解する必要があります。これらのピースは Components と呼ばれます。 作成したいオブジェクトの種類に応じて、異なる組み合わせのコンポーネントを GameObject に追加します。 GameObject は、空の鍋、コンポーネントはゲームプレイというレシピを構成する各種材料と考えてください。 スクリプトを使用して、自身でコンポーネントを作成することもできます。

本項のページでは、GameObject、コンポーネントおよびスクリプト コンポーネントについて記載されています。

• The GameObject-Component Relationship
• Using Components
• コンポーネントとスクリプトの関係
• Deactivating GameObjects

The GameObject-Component Relationship

As described previously in GameObjects, a GameObject contains Components. We'll explore this relationship by discussing a GameObject and its most common Component -- the Transform Component. With any Unity Scene open, create a new GameObject (using Shift-Control-N on Windows or Shift-Command-N on Mac), select it and take a look at the Inspector.

The Inspector of an Empty GameObject

Notice that an empty GameObject still contains a Name, a Tag, and a Layer. Every GameObject also contains a Transform Component.

The Transform Component

It is impossible to create a GameObject in Unity without a Transform Component. The Transform Component is one of the most important Components, since all of the GameObject's Transform properties are enabled by its use of this Component. It defines the GameObject's position, rotation, and scale in the game world/Scene View. If a GameObject did not have a Transform Component, it would be nothing more than some information in the computer's memory. It effectively would not exist in the world.

The Transform Component also enables a concept called Parenting, which is utilized through the Unity Editor and is a critical part of working with GameObjects. To learn more about the Transform Component and Parenting, read the Transform Component Reference page.

Other Components

The Transform Component is critical to all GameObjects, so each GameObject has one. But GameObjects can contain other Components as well.

The Main Camera, added to each scene by default

Looking at the Main Camera GameObject, you can see that it contains a different collection of Components. Specifically, a Camera Component, a GUILayer, a Flare Layer, and an Audio Listener. All of these Components provide additional functionality to the GameObject. Without them, there would be nothing rendering the graphics of the game for the person playing! Rigidbodies, Colliders, Particles, and Audio are all different Components (or combinations of Components) that can be added to any given GameObject.

Using Components40

Components are the nuts & bolts of objects and behaviors in a game. They are the functional pieces of every GameObject. If you don't yet understand the relationship between Components and GameObjects, read the GameObjects page before going any further.

A GameObject is a container for many different Components. By default, all GameObjects automatically have a Transform Component. This is because the Transform dictates where the GameObject is located, and how it is rotated and scaled. Without a Transform Component, the GameObject wouldn't have a location in the world. Try creating an empty GameObject now as an example. Click the GameObject->Create Empty menu item. Select the new GameObject, and look at the Inspector.

Even empty GameObjects have a Transform Component

Remember that you can always use the Inspector to see which Components are attached to the selected GameObject. As Components are added and removed, the Inspector will always show you which ones are currently attached. You will use the Inspector to change all the properties of any Component (including scripts)

Adding Components

You can add Components to the selected GameObject through the Components menu. We'll try this now by adding a Rigidbody to the empty GameObject we just created. Select it and choose Component->Physics->Rigidbody from the menu. When you do, you will see the Rigidbody's properties appear in the Inspector. If you press Play while the empty GameObject is still selected, you might get a little surprise. Try it and notice how the Rigidbody has added functionality to the otherwise empty GameObject. (The y-component of the GameObject starts to decrease. This is because the physics engine in Unity is causing the GameObject to fall under gravity.)

An empty GameObject with a Rigidbody Component attached

Another option is to use the Component Browser, which can be activated with the Add Component button in the object's inspector.

The browser lets you navigate the components conveniently by category and also has a search box that you can use to locate components by name.

You can attach any number or combination of Components to a single GameObject. Some Components work best in combination with others. For example, the Rigidbody works with any Collider. The Rigidbody controls the Transform through the NVIDIA PhysX physics engine, and the Collider allows the Rigidbody to collide and interact with other Colliders.

If you want to know more about using a particular Component, you can read about any of them in the Component Reference. You can also access the reference page for a Component from Unity by clicking on the small ? on the Component's header in the Inspector.

Editing Components

One of the great aspects of Components is flexibility. When you attach a Component to a GameObject, there are different values or Properties in the Component that can be adjusted in the editor while building a game, or by scripts when running the game. There are two main types of Properties: Values and References.

Look at the image below. It is an empty GameObject with an Audio Source Component. All the values of the Audio Source in the Inspector are the default values.

This Component contains a single Reference property, and seven Value properties. Audio Clip is the Reference property. When this Audio Source begins playing, it will attempt to play the audio file that is referenced in the Audio Clip property. If no reference is made, an error will occur because there is no audio to be played. You must reference the file within the Inspector. This is as easy as dragging an audio file from the Project View onto the Reference Property or using the Object Selector.

Now a sound effect file is referenced in the Audio Clip property

Components can include references to any other type of Component, GameObjects, or Assets. You can read more about assigning references on the Assigning References page.

The remaining properties on the Audio Clip are all Value properties. These can be adjusted directly in the Inspector. The Value properties on the Audio Clip are all toggles, numeric values, drop-down fields, but value properties can also be text strings, colors, curves, and other types. You can read more about these and about editing value properties on the Editing Value Properties page.

Copying and pasting Component settings

The context menu for a Component has items for copying and pasting its settings.

The copied values can be pasted to an existing component using the Paste Component Values menu item. Alternatively, you can use Paste Component As New to create a new Component with those values.

Testing out Properties

While your game is in Play Mode, you are free to change properties in any GameObject's Inspector. For example, you might want to experiment with different heights of jumping. If you create a Jump Height property in a script, you can enter Play Mode, change the value, and press the jump button to see what happens. Then without exiting Play Mode you can change it again and see the results within seconds. When you exit Play Mode, your properties will revert to their pre-Play Mode values, so you don't lose any work. This workflow gives you incredible power to experiment, adjust, and refine your gameplay without investing a lot of time in iteration cycles. Try it out with any property in Play Mode. We think you'll be impressed.

Changing the order of Components

The order in which components are listed in the Inspector doesn't matter in most cases. However, there are some Components, such as Image Effects where the ordering is significant. The context menu has Move Up and Move Down commands to let you reorder Components as necessary.

Removing Components

If you want to remove a Component, option- or right-click on its header in the Inspector, and choose Remove Component. Or you can left-click the options icon next to the ? on the Component header. All the property values will be lost and this cannot be undone, so be completely sure you want to remove the Component before you do.

The Component-Script Relationship

script 作成後、GameObject にこのスクリプトを追加すると、コンポーネントのような、GameObject のインスペクタでに表示されます。 これは、スクリプトが保存時に、コンポーネントになるためです。スクリプトは一種のコンポーネントです。 技術的な意味では、スクリプトはコンポーネントの一種としてコンパイルし、Unity エンジンによってその他のコンポーネント同様に微調整されます。 そのため、基本的に、スクリプトは、自身で作成するコンポーネントです。 インスペクタで表示するそのメンバーを定義すると、記述したすべての機能を実行します。

スクリプトの作成および使用の詳細については、Scripting ページを参照してください。

DeactivatingGameObjects

A GameObject can be temporarily removed from the scene by marking it as inactive. This can be done using its activeSelf property from a script or with the activation checkbox in the inspector

A GameObject's activation checkbox

Effect of deactivating a parent GameObject

When a parent object is deactivated, the deactivation also overrides the activeSelf setting on all its child objects, so the whole hierarchy from the parent down is made inactive. Note that this does not change the value of the activeSelf property on the child objects, so they will return to their original state once the parent is reactivated. This means that you can't determine whether or not a child object is currently active in the scene by reading its activeSelf property. Instead, you should use the activeInHierarchy property, which takes the overriding effect of the parent into account.

This overriding behaviour was introduced in Unity 4.0. In earlier versions, there was a function called SetActiveRecursively which could be used to activate or deactivate the children of a given parent object. However, this function worked differently in that the activation setting of each child object was changed - the whole hierarchy could be switched off and on but the child objects had no way to "remember" the state they were originally in. To avoid breaking legacy code, SetActiveRecursively has been kept in the API for 4.0 but its use is not recommended and it may be removed in the future. In the unusual case where you actually want the children's activeSelf settings to be changed, you can use code like the following:-

// JavaScript
function DeactivateChildren(g: GameObject, a: boolean) {
	g.activeSelf = a;

	for (var child: Transform in g.transform) {
		DeactivateChildren(child.gameObject, a);
	}
}


// C#
void DeactivateChildren(GameObject g, bool a) {
	g.activeSelf = a;

	foreach (Transform child in g.transform) {
		DeactivateChildren(child.gameObject, a);
	}
}

Using The Inspector

The Inspector is used to view and edit Properties of many different types.

Games in Unity are made up of multiple GameObjects that contain meshes, scripts, sounds, or other graphical elements like Lights. When you select a GameObject in the Hierarchy or Scene View, the Inspector will show and let you modify the Properties of that GameObject and all the Components and Materials on it. The same will happen if you select a Prefab in the Project View. This way you modify the functionality of GameObjects in your game. You can read more about the GameObject-Component relationship, as it is very important to understand.

Inspector shows the properties of a GameObject and the Components and Materials on it.

When you create a script yourself, which works as a custom Component type, the member variables of that script are also exposed as Properties that can be edited directly in the Inspector when that script component has been added to a GameObject. This way script variables can be changed without modifying the script itself.

Furthermore, the Inspector is used for showing import options of assets such as textures, 3D models, and fonts when selected. Some scene and project-wide settings are also viewed in the Inspector, such as all the Settings Managers.

Any property that is displayed in the Inspector can be directly modified. There are two main types of Properties: Values and References.

• Editing Value Properties
• リファレンスの割り当て
• Multi-Object Editing
• インスペクタ オプション

Editing Value Properties40

Value properties do not reference anything and they can be edited right on the spot. Typical value properties are numbers, toggles, strings, and selection popups, but they can also be colors, vectors, curves, and other types.

Value properties on the inspector can be numbers, checkboxes, strings...

Many value properties have a text field and can be adjusted simply by clicking on them, entering a value using the keyboard, and pressing Enter to save the value.

• You can also put your mouse next to a numeric property, left-click and drag it to scroll values quickly
• Some numeric properties also have a slider that can be used to visually tweak the value.

Some Value Properties open up a small popup dialog that can be used to edit the value.

Color Picker

Properties of the Color type will open up the Color Picker. (On Mac OS X this color picker can be changed to the native OS color picker by enabling Use OS X Color Picker under Unity->Preferences.)

The Color Picker reference in the inspector is represented by:

Color Picker reference in the inspector.

And opens the Color Picker just by clicking on it:

Color Picker descriptions.

Use the Eyedropper Tool when you want to find a value just by putting your mouse over the color you want to grab.
RGB / HSV Selector lets you switch your values from Red, Green, Blue to Hue, Saturation and Value (Strength) of your color.
Finally, the transparency of the Color selected can be controlled by the Alpha Channel value.

Curve Editor

Properties of the AnimationCurve type will open up the Curve Editor. The Curve Editor lets you edit a curve or choose from one of the presets. For more information on editing curves, see the guide on Editing Curves.

The type is called AnimationCurve for legacy reasons, but it can be used to define any custom curve function. The function can then be evaluated at runtime from a script.

An AnimationCurve property is shown in the inspector as a small preview:

A preview of an AnimationCurve in the Inspector.

Clicking on it opens the Curve Editor:

The Curve Editor is for editing AnimationCurves.

Wrapping Mode Lets you select between Ping Pong, Clamp and Loop for the Control Keys in your curve.
The Presets lets you modify your curve to default outlines the curves can have.

Gradient editor

In graphics and animation, it is often useful to be able to blend one colour gradually into another, over space or time. A gradient is a visual representation of a colour progression, which simply shows the main colours (which are called stops) and all the intermediate shades between them. In Unity, gradients have their own special value editor, shown below.

The upward-pointing arrows along the bottom of the gradient bar denote the stops. You can select a stop by clicking on it; its value will be shown in the Color box which will open the standard colour picker when clicked. A new stop can be created by clicking just underneath the gradient bar. The position of any of the stops can be changed simply by clicking and dragging and a stop can be removed with ctrl/cmd + delete.

The downward-pointing arrows above the gradient bar are also stops but they correspond to the alpha (transparency) of the gradient at that point. By default, there are two stops set to 100% alpha (ie, fully opaque) but any number of stops can be added and edited in much the same way as the colour stops.

Editing Reference Properties

リファレンス プロパティは、ゲーム オブジェクトやコンポーネント、アセットなどのその他のオブジェクトを参照するプロパティです。 リファレンス スロットは、このリファレンスに使用するオブジェクトの種類を表示します。

オーディオ クリッププロパティ スロットは、オーディオ クリップのオブジェクトへのリファレンスを受け付けることを示します。

現在、オーディオ クリップファイルは、オーディオ クリッププロパティで参照されています。

このタイプのリファレンスは、特にスクリプティング使用時には非常に高速で、強力です。 スクリプトとプロパティの使用については、チュートリアル ページのスクリプティング チュートリアルを参照してください。

オブジェクト リファレンスは、ドラッグ & ドロップか、Object Picker を使用するかのいずれかで、リファレンス プロパティに割り当てることができます。

ドラッグ & ドロップ

シーン ビュー、ヒエラルキー、またはプロジェクト ビューで対象のオブジェクトを選択して、リファレンス プロパティのスロットにドラッグするだけで、ドラッグ & ドロップを使用できます。

リファレンス プロパティが特定のコンポーネント タイプ (トランスフォームなど) を受け付ける場合、ゲーム オブジェクトまたはプレハブが正しいタイプのコンポーネントを含んでいれば、そのゲーム オブジェクトまたはプレハブをリファレンス プロパティにドラッグすると、うまくいきます。 ドラッグしたのはゲーム オブジェクトまたはプレハブですが、このプロパティが対象のコンポーネントを参照します。

オブジェクトをリファレンス プロパティにドラッグし、そのオブジェクトが正しいタイプでない場合、または正しいコンポーネントを含まない場合、そのオブジェクトをリファレンス プロパティに割り当てることはできません。

Object Picker

リファレンス スロットの隣にある小さい対象アイコンをクリックして、Object Picker を開くことができます。

エディタから Object Picker へのリファレンス。

Object Picker は、インスペクタ内のオブジェクトを割り当てる小さなウィンドウで、その前に、オブジェクトをプレビュー表示したり、使用可能にすることができます。

Object Picker は、非常に使いやすいのですが、気を付けなければならない点が幾つかあります。 以下に説明します。

Object Picker の構造

1. Search: ピッカーにオブジェクトがたくさんある場合、Search フィールドを使用してフィルタリングできます。 この検索フィールドで、Labels を使用してオブジェクトを検索できます。
2. View Selector: シーンとアセット内のオブジェクト間の検索のベースを切り替えます。
3. Preview Size: この水平スクロール バーで、プレビュー ウィンドウ内でのプレビュー オブジェクトのサイズを大きくしたり、小さくしたりできます。 これにより、いつでもプレビュー ウィンドウでのオブジェクトを数を増やしたり、減らしたりできます。
4. Preview Window: Search フィールドでフィルタリングされた Scene/Assets folder 内のすべてのオブジェクトが表示されます。
5. Object Info: 現在選択されているオブジェクトに関する情報を表示します。 このフィールドの内容は、表示されているオブジェクトの種類によって決まるため、例えば、メッシュを選択すると、頂点と三角形の数、UV があるか、スキンされているかが表示されます。 しかし、オーディオ ファイルを選択すると、オーディオのビット レートや長さなどの情報が表示されます。
6. Object Preview: これも表示されているオブジェクトの種類によって決まります。 メッシュを選択すると、メッシュの外観を表示しますが、スクリプト ファイルを選択すると、ファイルのアイコンのみを表示します。

Object Picker は、プロジェクト内のアセットで機能しますが、これには、ビデオや歌、地形、GUI スキン、スクリプティング ファイル、またはメッシュなどが該当します。頻繁に使うツールです。

ヒント

• アセットで Labels を使用すると、Object Picker の検索フィールドを使用して、アセットをより簡単に検索できます。
• オブジェクトの説明を確認したくない場合は、プレビュー ウィンドウの下中央にあるスライダーを下方に動かします。
• オブジェクトの詳細なプレビューを確認したい場合は、プレビュー ウィンドウの下中央にあるスライダーをドラッグすることで、オブジェクトを拡大できます。

Multi-Object Editing

Starting in Unity 3.5 you can select multiple objects of the same type and edit them simultaneously in the Inspector. Any changed properties will be applied to all of the selected objects. This is a big time saver if you want to make the same change to many objects.

When selecting multiple objects, a component is only shown in the Inspector if that component exists on all the selected objects. If it only exists on some of them, a small note will appear at the bottom of the Inspector saying that components that are only on some of the selected objects cannot be multi-edited.

Property Values

When multiple objects are selected, each property shown in the Inspector represents that property on each of the selected objects. If the value of the property is the same for all the objects, the value will be shown as normal, just like when editing a single object. If the value of the property is not the same for all the selected objects, no value is shown and a dash or similar is shown instead, indicating that the values are different.

Regardless of whether a value is shown or a dash, the property value can be edited as usual and the changed value is applied to all the selected objects. If the values are different and a dash is thus shown, it's also possible to right-click on the label of the property. This brings up a menu that lets you choose from which of the objects to inherit the value.

Multi-Editing Prefab or Model Instances

Prefabs can be multi-edited just like Game Objects in the scene. Instances of prefabs or of models can also be multi-edited; however certain restrictions apply: When editing a single prefab or model instance, any property that is different from the prefab or model will appear in bold, and when right clicking there's an option to revert the property to the value it has in the prefab or model. Furthermore, the Game Object has options to apply or revert all changes. None of these things are available when multi-object editing. Properties cannot be reverted or applied; nor will they appear in bold if different from the prefab or model. To remind you of this, the Inspector will show a note with Instance Management Disabled where the Select, Revert, and Apply buttons would normally appear.

Non-Supported Objects

A few object types do not support multi-object editing. When you select multiple objects simultaneously, these objects will show a small note saying "Multi-object editing not supported".

If you have made a custom editor for one of your own scripts, it will also show this message if it doesn't support multi-object editing. See the script reference for the Editor class to learn how to implement support for multi-object editing for your own custom editors.

Inspector Options

インスペクタ ロックおよびインスペクタ デバッグ モードは、ワークフローで役に立つ便利な 2 つのオプションです。

ロック

ロックにより、インスペクタの GameObject へのフォーカスを維持しつつ、その他の GameObject を選択できます。 インスペクタのロックを切り替えるには、インスペクタ上の「lock/unlock」 () アイコンをクリックするか、タブ メニューを開き、Lock を選択します。

「タブ メニューからインスペクタをロックします。」

複数のインスペクタを開くことができ、例えば、インスペクタの 1 つを GameObject にロックし、他方の GameObject をロックされていない状態にして、どの GameObject が選択されているかを表示できます。

デバッグ

デバッグ モードにより、インスペクタで、通常は表示されないコンポーネントのプライベート変数を検査できます。 デバッグ モードに変更するには、タブ メニューを開いて、Debug を選択します。

デバッグ モードで、すべてのコンポーネントは、通常モードで一部のコンポーネントが使用するカスタムのインターフェースではなく、デフォルトのインターフェースを使用して表示されます。 例えば、デバッグ モードでのトランスフォーム コンポーネントは、通常モードで表示されるオイラー角ではなく、回転のそのままの Quaternion 値を表示します。 また、デバッグ モードを使用して、自身のスクリプト コンポーネントのプライベート変数の値を検査できます。

「インスペクタのデバッグ モードにより、スクリプトおよびその他のコンポーネントでプライベート変数を検査できます。」

デバッグ モードは、インスペクタごとで、デバッグ モードでは 1 つのインスペクタを持つことができますが、別のインスペクタを持つことはできません。

Using The Scene View

The Scene View is your interactive sandbox. You will use the Scene View to select and position environments, the player, the camera, enemies, and all other GameObjects. Maneuvering and manipulating objects within the Scene View are some of the most important functions in Unity, so it's important to be able to do them quickly.

• Scene View Navigation
• GameObjects の配置
• View Modes
• Gizmo and Icon Display Controls

Scene View Navigation

The Scene View has a set of navigation controls to help you move around quickly and efficiently.

Arrow Movement

You can use the Arrow Keys to move around the scene as though "walking" through it. The up and down arrows move the camera forward and backward in the direction it is facing. The left and right arrows pan the view sideways. Hold down the Shift key with an arrow to move faster.

Focusing

If you select a GameObject in the hierarchy, then move the mouse over the scene view and press the F key, the view will move so as to center on the object. This feature is referred to as frame selection.

Move, Orbit and Zoom

Moving, orbiting and zooming are key operations in Scene View navigation, so Unity provides several alternative ways to perform them for maximum convenience.

Using the Hand Tool

When the hand tool is selected (shortcut: Q), the following mouse controls are available:

Move: Click-drag to drag the camera around.
Orbit: Hold Alt and click-drag to orbit the camera around the current pivot point.
Zoom: Hold Control (Command on Mac) and click-drag to zoom the camera.

Holding down Shift will increase the rate of movement and zooming.

Shortcuts Without Using the Hand Tool

For extra efficiency, all of these controls can also be used regardless of which transform tool is selected. The most convenient controls depend on which mouse or track-pad you are using:

Flythrough Mode

The Flythrough mode lets you navigate the Scene View by flying around in first person similar to how you would navigate in many games.

• Click and hold the right mouse button.
• Now you can move the view around using the mouse and use the WASD keys to move left/right forward/backward and the Q and E keys to move up and down.
• Holding down Shift will make you move faster.

Flythrough mode is designed for Perspective Mode. In Isometric Mode, holding down the right mouse button and moving the mouse will orbit the camera instead.

Scene Gizmo

In the upper-right corner of the Scene View is the Scene Gizmo. This displays the Scene View Camera's current orientation, and allows you to quickly modify the viewing angle.

You can click on any of the arms to snap the Scene View Camera to that direction. Click the middle of the Scene Gizmo, or the text below it, to toggle between Isometric Mode and Perspective Mode. You can also always shift-click the middle of the Scene Gizmo to get a "nice" perspective view with an angle that is looking at the scene from the side and slightly from above.

Perspective mode.

Isometric mode. Objects do not get smaller with distance here!

Mac Trackpad Gestures

On a Mac with a trackpad, you can drag with two fingers to zoom the view.

You can also use three fingers to simulate the effect of clicking the arms of the Scene Gizmo: drag up, left, right or down to snap the Scene View Camera to the corresponding direction. In OS X 10.7 "Lion" you may have to change your trackpad settings in order to enable this feature:

• Open System Preferences and then Trackpad (or type trackpad into Spotlight).
• Click into the "More Gestures" option.
• Click the first option labelled "Swipe between pages" and then either set it to "Swipe left or right with three fingers" or "Swipe with two or three fingers".

Positioning GameObjects

ゲーム作成時に、ゲームの世界に各種オブジェクトを置くことになるでしょう。

フォーカシング

操作前にシーン ビュー カメラのフォーカスをオブジェクトに合わせると便利な場合があります。 GameObject を選択して、F キーを押します。 これにより、選択範囲でシーン ビューおよびピボット点が中央に配置されます。 これはフレーム選択とも呼ばれます。

移動、回転および縮小拡大

ツールバーのトランスフォーム ツールを使用して、個々の GameObject を移動、回転、縮小拡大します。 それぞれに、シーンビュー内で選択した GameObject 周辺に表示される対応するギズモがあります。 マウスを使用し、ギズモ軸を操作して、GameObject の Transform コンポーネントを変更したり、またはインスペクタのトランスフォーム コンポーネントの数字フィールドに直接値を入力できます。Each of the three transform modes can be selected with a hotkey - W for Translate, E for Rotate and R for Scale.

• クリックして、ギズモの中心でドラッグすると、オブジェクトをすべての軸で一度に操作することができます。
• At the center of the Translate gizmo, there are three small squares that can be used to drag the object within a single plane (ie, two axes can be moved at once while the third is kept still).
• 3 ボタン マウスの場合、中央ボタンをクリックして、最後に調整した軸 (黄色に変わります) を直接クリックせずに、調整できます。
• スケーリング ツール使用時は、不均一なスケール (1、2、1 など) により子オブジェクトに対して、異常なスケーリングが発生する場合があります。
• GameObject の変形の詳細については、Transform Component ページを参照してください。

Gizmo Display Toggles

Gizmo Display Toggles は、トランスフォーム ギズモの位置を定義します。

Gizmo Display Toggles

• 位置:
  • Center は、オブジェクトのレンダリング バウンドの中心にギズモを配置します。
  • Pivot は、メッシュの実際のピボット点にギズモを配置します。
• 回転:
  • Local オブジェクトの回転に対して、ギズモの回転を維持します。
  • Global は、ギズモを世界空間の方向に固定します。

Unit Snapping

移動ツールを使用して、ギズモ軸をドラッグしたまま、Control キー (Mac の場合、Command) を押したままにすると、Snap Settings で定義された増分にスナップできます。

メニュー Edit->Snap Settings... を使用して、単位スナッピングに使用される単位距離を変更できます。

シーン ビューの単位スナッピング設定

Surface Snapping

移動ツールを使用して、中心でドラッグしたまま、Shift と　Control キー (Mac の場合、Command) を押したままにすると、Collider の交差部にオブジェクトをスナップできます。 これによって、オブジェクトを驚くほど素早く正確に配置できます。

Look-At Rotation

回転ツールを使用して、Shift と　Control キー (Mac の場合、Command) を押したままにすると、Collider の表面の点に対して、オブジェクトを回転できます。 これにより、それぞれに対するオブジェクトの方向をシンプルできます。

Vertex Snapping

Vertex Snapping 機能を使用して、世界をより簡単に組み立てることができます。 この機能は非常にシンプルですが、強力な Unity のツールです。 これにより、所定のメッシュから頂点を取り、マウスで、その頂点を選択したほかのメッシュからの頂点と同じ位置に配置できます。

この機能を使えば、世界を実に素早く組み立てることができます。 例えば、レース ゲームで高精度の道路を置いたり、メッシュの頂点にパワアップアイテムを追加したりできます。

Vertex Snapping での道路の組み立て

Unityでの Vertex Snapping の使用は非常に簡単です。 次の手順に従うだけで使用できます。

• 操作したいメッシュを選択し、トランスフォーム ツールがアクティブになるのを確認します。
• V キーを押したままにすると、Vertex Snapping モードが起動します。
• ピボット点として使用したいメッシュ上の頂点にマウスのカーソルを合わせます。
• カーソルを希望の頂点に合わせたら、左ボタンを押したままにし、メッシュを別のメッシュ上の別の頂点の隣にドラッグします。
• 結果に満足したら、マウスのボタンと V キーを離します。
• Shift-V で、この機能のオンオフを切り替えることができます。
• 頂点から頂点、頂点から表面、ピボットから頂点へとスナップできます。

Vertex snapping の使用法を映したビデオは、here にあります。

View Modes

The Scene View control bar lets you choose various options for viewing the scene and also control whether lighting and audio are enabled. These controls only affect the scene view during development and have no effect on the built game.

Draw Mode

The first drop-down menu selects which Draw Mode will be used to depict the scene.

Draw Mode drop-down

• Textured: show surfaces with their textures visible.
• Wireframe: draw meshes with a wireframe representation.
• Tex-Wire: show meshes textured and with wireframes overlaid.
• Render Paths: show the rendering path for each object using a color code: Green indicates deferred lighting, yellow indicates forward rendering and red indicates vertex lit.
• Lightmap Resolution: overlay a checkered grid on the scene to show the resolution of the lightmaps.

Render Mode

The next drop-down along selects which of four Render Modes will be used to render the scene.

Render Mode drop-down

• RGB: render the scene with objects normally colored.
• Alpha: render colors with alpha.
• Overdraw: render objects as transparent "silhouettes". The transparent colors accumulate, making it easy to spot places where one object is drawn over another.
• Mipmaps: show ideal texture sizes using a color code: red indicates that the texture is larger than necessary (at the current distance and resolution); blue indicates that the texture could be larger. Naturally, ideal texture sizes depend on the resolution at which the game will run and how close the camera can get to particular surfaces.

Scene Lighting, Game Overlay, and Audition Mode

To the right of the dropdown menus are three buttons which control other aspects of the scene representation.

The first button determines whether the view will be lit using a default scheme or with the lights that have actually been added to the scene. The default scheme is used initially but this will change automatically when the first light is added. The second button controls whether skyboxes and GUI elements will be rendered in the scene view and also shows and hides the placement grid. The third button switches audio sources in the scene on and off.

Gizmo and Icon Visibility

Gizmos and icons have a few display options which can be used to reduce clutter and improve the visual clarity of the scene during development.

The Icon Selector

Using the Icon Selector, you can easily set custom icons for GameObjects and scripts that will be used both in the Scene View and the Inspector. To change the icon for a GameObject, simply click on its icon in the Inspector. The icons of script assets can be changed in a similar way. In the Icon Selector is a special kind of icon called a Label Icon. This type of icon will show up in the Scene View as a text label using the name of the GameObject. Icons for built-in Components cannot be changed.

Selecting an icon for a GameObject

Selecting an icon for a script

Showing and Hiding Icons and Gizmos

The visibility of an individual component's gizmos depends on whether the component is expanded or collapsed in the inspector (ie, collapsed components are invisible). However, you can use the Gizmos dropdown to expand or collapse every component of a given type at once. This is a useful way to reduce visual clutter when there are a large number of gizmos and icons in the scene.

To show the state of the current gizmo and icon, click on Gizmos in the control bar of the Scene or Game View. The toggles here are used to set which icons and gizmos are visible.

Note that the scripts that show up in the Scripts section are those that either have a custom icon or have an OnDrawGizmos () or OnDrawGizmosSelected () function implemented.

The Gizmos dropdown, displaying the visibility state of icons and gizmos

The Icon Scaling slider can be used to adjust the size used for icon display in the scene. If the slider is placed at the extreme right, the icon will always be drawn at its natural size. Otherwise, the icon will be scaled according to its distance from the scene view camera (although there is an upper limit on the display size in order that screen clutter be avoided).

Searching

When working with large complex scenes it can be useful to search for specific objects. By using the Search feature in Unity, you can filter out only the object or group of objects that you want to see. You can search assets by their name, by Component type, and in some cases by asset Labels. You can specify the search mode by choosing from the Search drop-down menu.

Scene Search

When a scene is loaded in the Editor, you can see the objects in both the Scene View and the Hierarchy. The specific assets are shared in both places, so if you type in a search term (eg, "elevator"), you'll see the the filter applied both visually in the Scene View and a more typical manner in the Hierarchy. There is also no difference between typing the search term into the search field in the Scene View or the Hierachy -- the filter takes effect in both views in either case.

Scene View and Hierarchy with no search applied.

Scene View and Hierarchy with active filtering of search term.

When a search term filter is active, the Hierarchy doesn't show hierarchical relationships between GameObjects, but you can select any GameObject, and it's hierarchical path in the scene will be shown at the bottom of the Hierarchy.

Click on a GameObject in the filtered list to see its hierarchical path.

When you want to clear the search filter, just click the small cross in the search field.

In the Scene search you can search either by Name or by Type. Click on the small magnifying glass in the search field to open the search drop-down menu and choose the search mode.

Search by Name, Type, or All.

Project Search

The same fundamentals apply to searching of assets in the Project View -- just type in your search term and you'll see all the relevant assets appear in the filter.

In the Project search you can search by Name or by Type as in the Scene search, and additionally you can search by Label. Click on the small magnifying glass in the search field to open the search drop-down menu and choose the search mode.

Search by Name, Type, Label, or All.

Object Picker Search

When assigning an object via the Object Picker, you can also enter a search term search to filter the objects you want to see.

Prefabs

A Prefab is a type of asset -- a reusable GameObject stored in Project View. Prefabs can be inserted into any number of scenes, multiple times per scene. When you add a Prefab to a scene, you create an instance of it. All Prefab instances are linked to the original Prefab and are essentially clones of it. No matter how many instances exist in your project, when you make any changes to the Prefab you will see the change applied to all instances.

Creating Prefabs

In order to create a Prefab, simply drag a GameObject that you've created in the scene into the Project View. The GameObject's name will turn blue to show that it is a Prefab. You can rename your new Prefab.

After you have performed these steps, the GameObject and all its children have been copied into the Prefab data. The Prefab can now be re-used in multiple instances. The original GameObject in the Hierarchy has now become an instance of the Prefab.

Prefab Instances

To create a Prefab instance in the current scene, drag the Prefab from the Project View into the Scene or Hierarchy View. This instance is linked to the Prefab, as displayed by the blue text used for their name in the Hierarchy View.

Three of these GameObjects are linked to Prefabs. One of them is not.

• If you have selected a Prefab instance, and want to make a change that affects all instances, you can click the Select button in the Inspector to select the source Prefab.
• Information about instantiating prefabs from scripts is in the Instantiating Prefabs page.

Inheritance

Inheritance means that whenever the source Prefab changes, those changes are applied to all linked GameObjects. For example, if you add a new script to a Prefab, all of the linked GameObjects will instantly contain the script as well. However, it is possible to change the properties of a single instance while keeping the link intact. Simply change any property of a prefab instance, and watch as the variable name becomes bold. The variable is now overridden. All overridden properties will not be affected by changes in the source Prefab.

This allows you to modify Prefab instances to make them unique from their source Prefabs without breaking the Prefab link.

A linked GameObject with no overrides enabled.

A linked GameObject with several (bold) overrides enabled.

• If you want to update the source Prefab and all instances with the new overridden values, you can click the Apply button in the Inspector.
  • Note that the root's position and rotation will not be applied, as that affects the instances absolute position and would put all instances in the same place. However position and rotation from any children or ancestors of the root will be applied as they are computed relative to the root's transform.
• If you want to discard all overrides on a particular instance, you can click the Revert button.

Imported Prefabs

When you place a mesh asset into your Assets folder, Unity automatically imports the file and generates something that looks similar to a Prefab out of the mesh. This is not actually a Prefab, it is simply the asset file itself. Instancing and working with assets introduces some limitations that are not present when working with normal Prefabs.

Notice the asset icon is a bit different from the Prefab icons

The asset is instantiated in the scene as a GameObject, linked to the source asset instead of a normal Prefab. Components can be added and removed from this GameObject as normal. However, you cannot apply any changes to the asset itself since this would add data to the asset file itself! If you're creating something you want to re-use, you should make the asset instance into a Prefab following the steps listed above under "Creating Prefabs".

• When you have selected an instance of an asset, the Apply button in the Inspector is replaced with an Edit button. Clicking this button will launch the editing application for your asset (e.g. Maya or Max).

Lights

Lights は、すべてのシーンの重要な部分です。 メッシュおよびテクスチャは、シーンの形状と見た目を定義し、ライトは 3D 環境の色やムードを定義します。 各シーンで複数のライトを扱うことになるでしょう。 これらを連携させるには、少しの実践が必要ですが、結果は驚くほど素晴らしいものになるでしょう。

簡単な、2 つのライトのある設定

ライトは、GameObject->Create Other メニューからシーンに追加できます。 ライトを追加すると、その他の GameObject のように操作できます。 また、Component->Rendering->Light を使用して、選択した GameObject にライト コンポーネントを追加できます。

Inspector のライト コンポーネントには多くの各種オプションがあります。

インスペクタ内のライト コンポーネント プロパティ

ライトのColorを変更するだけで、シーンのムード全体を変えることができます。

明るい太陽のようなライト

暗い中世のライト

不気味な夜のライト

このように作成したライトは、realtime ライトになります。そのライティングは、ゲーム実行中、フレームごとに計算されます。 ライトが変わらないと分かっている場合、Lightmapping を使用して、ゲームをより高速かつ、見た目も向上できます。

レンダリング パス

Unity は、各種レンダリング パスをサポートしています。これらのパスは、主にライトやシャドウに影響するため、ゲームの要件に基づいた正しいレンダリング パスの選択により、プロジェクトのパフォーマンスを向上できます。 レンダリング パスの詳細については、 Rendering paths section を参照してください。

詳細

ライトの使用に関する詳細については、Reference Manual の Lights page を参照してください。

Cameras

Just as cameras are used in films to display the story to the audience, Cameras in Unity are used to display the game world to the player. You will always have at least one camera in a scene, but you can have more than one. Multiple cameras can give you a two-player splitscreen or create advanced custom effects. You can animate cameras, or control them with physics. Practically anything you can imagine is possible with cameras, and you can use typical or unique cameras to fit your game's style.

The remaining text is from the Camera Component reference page.

カメラ

Cameras は、世界を切り取り、プレイヤーに表示する装置です。 カメラをカスタマイズし、操作することで、本当に自分なりの表現を行うことができます。 シーン内では、カメラを好きなだけ使用できます。 レンダリングの順序や、スクリーン上の位置、又は、スクリーンの一部だけを表示するように設定することも可能です。

「Unity の柔軟なカメラ オブジェクト」

プロパティ

詳細

カメラは、プレイヤーにゲームを表示するのに重要です。 想像できるあらゆる種類の効果が得られるよう、カメラをカスタマイズ、記述またはパレンディングできます。 パズル ゲームの場合、パズル全体のビューに対して、カメラを静止に維持できます。 1 人称シューティングの場合、カメラをプレイヤーのキャラクターにパレンディングして、キャラクターの目線に配置することができます。 レース ゲームの場合、カメラがプレイヤーの後を追うように動かすことができます。

複数のカメラを作成し、それぞれに異なる「Depth」を割り当てることができます。 低い「Depth」から高い「Depth」にカメラが描画されます。 言い換えると、「Depth」が 2 のカメラは、「Depth」が　1 のカメラの上に描画されます。「Normalized View Port Rectangle」プロパティの値を調整して、画面上のカメラのビューのサイズ変更や配置を行うことができます。 これにより、ミサイル カムや、マップ ビュー、バック ミラーのような複数の小さいビューを作成できます。

レンダリング パス

Unity は、異なるレンダリング パスをサポートしています。 ゲームの内容や対象のプラットフォーム / ハードウェアに応じて、どのパスを使用するかを選ぶ必要があります。 レンダリング パスによって、主に光や影に影響する機能およびパフォーマンス特性が異なります。 プロジェクトに使用されるレンダリング パスはプレイヤー設定で選択されます。 さらに、各カメラに対して、レンダリング パスを無効にできます。

レンダリング パスの詳細については、rendering paths page を参照してください。

Clear Flags

各カメラは、そのビューをレンダリングする際に、色と深さに関する情報を記憶します。 描画されない画面の部分は空で、デフォルトではスカイボックスが表示されます。 複数のカメラを使用する場合、それぞれのカメラがバッファに色と深さに関する情報を記憶し、各カメラがレンダリングを行う際に、より多くのデータを蓄積します。 シーンで任意のカメラがそのビューをレンダリングするため、「Clear Flags」を設定して、バッファ情報の異なる集合をクリアできます。 これは、次の 4 つのオプションを選択することで行うことができます。

スカイボックス

これはデフォルトの設定です。 画面の空白の部分には、現在のカメラのスカイボックスが表示されます。 現在のカメラにスカイボックスが設定されない場合、Render Settings （Edit->Render Settings で表示） で選択したスカイボックスに戻ります。 これにより、「Background Color」に戻ります。 そうでない場合は、Skybox component をカメラに追加できます。 スカイボックスを新規作成したい場合は、you can use this guide を参照してください。

Solid Color

画面の空白の部分には、現在のカメラの「Background Color」が表示されます。

Depth Only

環境内でプレイヤーの銃を切り取らずに描画したい場合、1 台のカメラに対して「Depth」を 0 に設定して、環境を描画し、もう 1 台のカメラの「Depth」を 1 に設定して、武器のみを描画させます。 武器を表示するカメラの「Clear Flags」は、「Depth only」に設定する必要があります。 これにより、環境の映像表示が画面に維持されますが、各オブジェクトが 3D スペースに存在する場所に関する情報はすべて破棄されます。 銃が描画されると、銃がどの程度壁に近いかに関係なく、不透明な部分が描画されたものをすべて完全に覆います。

「銃は、カメラの深さバッファが描画前にクリアされた後に、最後に描画されます」

Don't Clear

このモードでは、色および深さバッファのいずれもクリアされません。 その結果、各フレームが次のフレーム上に描画され、シミのように見える効果が得られます。 これは通常ゲームでは使用されず、カスタムのシェーダーと併用される場合に最適です。

Clip Planes

「Near」と「Far Clip Plane」プロパティは、カメラのビューの開始および終了場所を決定します。 カメラの方向に対して垂直に面が配置され、その位置から測定されます。 「Near plane」は、レンダリングされる最も近い場所で、「Far plane」は最も遠い場所になります。

また、切り取り面は、バッファの精度が画面上にどのように分配されるかを決定します。 一般に、精度を高めるには、「Near plane」をできる限り遠くに移動する移動させる必要があります。

近くまたは遠くの切り取り面は、カメラのビューのフィールドで定義された面と共に、一般的にカメラの「錐台」と知られているものを記述します。 Unity では、オブジェクトをレンダリングする際に、この錐台外にあるオブジェクトは表示されません。 これは、錐台カリングと呼ばれます。 錐台カリングは、ゲーム内でオクルージョン カリングが使用されているか否かに関係なく発生します。

パフォーマンス上の理由から、より小さいオブジェクトを早めに間引きたい場合があるでしょう。 例えば、小さい岩や破片を大きい建物よりもより少ない距離で非表示にできます。 これを行うには、小さいオブジェクトを separate layer に置き、Camera.layerCullDistances スクリプト機能を使用して、レイヤーごとの間引き距離を設定できます。

Culling Mask

「Culling Mask」は、レイヤーを使用してオブジェクトのグループを選択的にレンダリングするのに使用されます。 * レイヤーの使用法については、here を参照してください。

異なるレイヤーにユーザー インターフェースを配置し、UI レイヤー自体で個々のカメラでユーザー インターフェース自体をレンダリングするのが一般的です。

また、UI をその他のカメラ ビューの上に表示するには、「Clear Flags」を「Depth only」に設定し、UI カメラの「Depth」をその他のカメラよりも高くする必要があります。

Normalized Viewport Rectangle

「Normalized Viewport Rectangles」は、現在のカメラ ビューが描画される画面の一定の部分を定義するためのものです。 画面の左下ににマップ ビューを、右上にミサイルチップ ビューを配置できます。 少し設計を行うだけで、「Viewport Rectangle」を使用して、独自の動作を作成できます。

「Normalized Viewport Rectangle」を使用して、2 プレイヤー用に 2 分割した画面効果を簡単に作成できます。 2 台のカメラを作成後、カメラの H 値を 0.5 に設定し、プレイヤー 1 の Y 値を 0.5 に、プレイヤー 2 の Y 値を 0 に変更します。これにより、プレイヤー 1 のカメラが画面の半分上から上部に表示され、プレイヤー 2 のカメラが下部で始まり、画面の半分で停止します。

「「Normalized Viewport Rectangle」で作成された 2 プレイヤー用表示」

Orthographic

カメラを「Orthographic」にすると、カメラ のビューからすべての景色が削除されます。 これは、等角または 2D　ゲームの作成に便利です　。

霧は Orthographic カメラ モードで均一にレンダリングされるため、期待通りには表示されません。 理由については、component reference on Render Settings を参照してください。

「Perspective カメラ」

「Orthographic カメラ」 オブジェクトはここでの距離で小さくなりません。」

Render Texture

この機能は、Unity Advance ライセンスでのみ使用できます。 カメラのビューを、別のオブジェクトに適用される Texture に配置します。 これにより、競技場のビデオ モニターや監視カメラ、反射などを簡単に作成できます。

「アリーナの実況カメラの作成に使用される Render Texture」

ヒント

• その他の GameObject 同様、カメラはインスタンス化、パレンディング、および記述できます。
• レース ゲームでスピード感を高めるには、「Field of View」を高くします。
• Rigidbody コンポーネントを追加すると、物理特性のシミュレーションでカメラを使用できます。
• シーンで使用できるカメラの数には制限はありません。
• Orthographic カメラは、3D ユーザー インターフェースをさくせいするのにべんりです　。
• 深さのアーティファクトを経験している場合は （互いに近い面のちらつき）、「Near Plane」をできる限り大きく設定してみてください。
• カメラは、ゲーム画面および Render Texture に対して同時にレンダリングできません。いずれかのみになります。
• Pro のライセンスを所有している場合、より独自の効果を得るために、テクスチャにカメラのビューをレンダリングするためのオプション、Render-to-Texture を利用できます。
• Unity には、Components->Camera Control から利用できるプリインストールされたカメラ スクリプトが用意されています。 これらを試して、何ができるかを試してみてください。

Terrains

このセクションではTerrain Engine（地形エンジン）の使用方法について説明します。作成の方法、技術的な詳細、その他の考慮事項をカバーします。次のセクションに分かれています：

Using Terrains

このセクションではTerrainの基本的な情報についてカバーします。これはTerrainの作成方法と新しいTerrainツールおよびブラシの使用方法を含みます。

Height

このセクションでは異なるツールおよびブラシを使用してTerrain（地形）のHeight（高さ）を変更する方法を説明します。

Terrain Textures

このセクションでは異なるブラシを使用して、Terrainテクスチャを追加、ペイント、ブレンドする方法を説明します。

Trees

このセクションではツリーアセットを作成する際に重要な情報を説明します。さらにTerrain上でツリーを追加、ペイントする方法もカバーします。

Grass

このセクションではGrass（草）の仕組みと使用方法を説明します。

Detail Meshes

このセクションでは詳細メッシュ（岩、ワラ、植生）の実践的な使用方法を説明します。

Lightmaps

Unity内臓のLightmapperにより他のどのようなオブジェクトとも同じようにTerrainにライトマップを適用することが出来ます。ヘルプが必要な場合はLightmap クイックスタート を参照のこと。

他の設定

このセクションではTerrainに関するその他全ての設定をカバーします。

モバイル　パフォーマンスに関する留意事項

Terrainのレンダリングは相当にコストがかかるため、ローエンドのモバイルデバイスでは実用的ではありません。

Asset Import and Creation

A large part of making a game is utilizing your asset source files in your GameObjects. This goes for textures, models, sound effects and behaviour scripts. Using the Project View inside Unity, you have quick access to all the files that make up your game:

The Project View displays all source files and created Prefabs

This view shows the organization of files in your project's Assets folder. Whenever you update one of your asset files, the changes are immediately reflected in your game!

To import an asset file into your project, move the file into (your Project folder)->Assets in the Finder, and it will automatically be imported into Unity. To apply your assets, simply drag the asset file from the Project View window into the Hierarchy or Scene View. If the asset is meant to be applied to another object, drag the asset over the object.

Hints

• It is always a good idea to add labels to your assets when you are working with big projects or when you want to keep organized all your assets, with this you can search for the labels associated to each asset in the search field in the project view.
• When backing up a project folder always back up Assets, ProjectSettings and Library folders. The Library folder contains all meta data and all the connections between objects, thus if the Library folder gets lost, you will lose references from scenes to assets. Easiest is just to back up the whole project folder containing the Assets, ProjectSettings and Library folders.
• Rename and move files to your heart's content inside Project View; nothing will break.
• Never rename or move anything from the Finder or another program; everything will break. In short, Unity stores lots of metadata for each asset (things like import settings, cached versions of compressed textures, etc.) and if you move a file externally, Unity can no longer associate metadata with the moved file.

Continue reading for more information:

• Importing Assets
• Mesh
  • 3Dフォーマット
• Animations (Legacy)
• Materials and Shaders
• Textures
• Procedural Materials
• Movie Textures
• Audio Files
  • Tracker Modules
• Using Scripts
• Asset Store
• Asset Server (Pro Only)
  • Cache Server (Team license only)
  • Cache Server FAQ
• Behind the Scenes

Importing Assets

Unity will automatically detect files as they are added to your Project folder's Assets folder. When you put any asset into your Assets folder, you will see the asset appear in your Project View.

The Project View is your window into the Assets folder, normally accessible from the file manager

When you are organizing your Project View, there is one very important thing to remember:

Never move any assets or organize this folder from the Explorer (Windows) or Finder (OS X). Always use the Project View!

There is a lot of meta data stored about relationships between asset files within Unity. This data is all dependent on where Unity expects to find these assets. If you move an asset from within the Project View, these relationships are maintained. If you move them outside of Unity, these relationships are broken. You'll then have to manually re-link lots of dependencies, which is something you probably don't want to do.

So just remember to only save assets to the Assets folder from other applications, and never rename or move files outside of Unity. Always use Project View. You can safely open files for editing from anywhere, of course.

Creating and Updating Assets

When you are building a game and you want to add a new asset of any type, all you have to do is create the asset and save it somewhere in the Assets folder. When you return to Unity or launch it, the added file(s) will be detected and imported.

Additionally, as you update and save your assets, the changes will be detected and the asset will be re-imported in Unity. This allows you to focus on refining your assets without struggling to make them compatible with Unity. Updating and saving your assets normally from its native application provides optimum, hassle-free workflow that feels natural.

Asset Types

There are a handful of basic asset types that will go into your game. The types are:

• Mesh Files & Animations
• Texture Files
• Sound Files

We'll discuss the details of importing each of these file types and how they are used.

Meshes & Animations

Whichever 3D package you are using, Unity will import the meshes and animations from each file. For a list of applications that are supported by Unity, please see this page.

Your mesh file does not need to have an animation to be imported. If you do use animations, you have your choice of importing all animations from a single file, or importing separate files, each with one animation. For more information about importing animations, please see page about Animation Import.

Once your mesh is imported into Unity, you can drag it to the Scene or Hierarchy to create an instance of it. You can also add Components to the instance, which will not be attached to mesh file itself.

Meshes will be imported with UVs and a number of default Materials (one material per UV). You can then assign the appropriate texture files to the materials and complete the look of your mesh in Unity's game engine.

Textures

Unity supports all image formats. Even when working with layered Photoshop files, they are imported without disturbing the Photoshop format. This allows you to work with a single texture file for a very care-free and streamlined experience.

You should make your textures in dimensions that are to the power of two (e.g. 32x32, 64x64, 128x128, 256x256, etc.) Simply placing them in your project's Assets folder is sufficient, and they will appear in the Project View.

Once your texture has been imported, you should assign it to a Material. The material can then be applied to a mesh, Particle System, or GUI Texture. Using the Import Settings, it can also be converted to a Cubemap or Normalmap for different types of applications in the game. For more information about importing textures, please read the Texture Component page.

Sounds

Desktop

iOS

Android

Once sound files are imported, they can be attached to any GameObject. The Audio file will create an Audio Source Component automatically when you drag it onto a GameObject.

Meshes

3Dモデルをインポートすると、UnityはMeshとして内部的に格納します。MeshはMeshフィルタ コンポーネント を使用してゲームオブジェクトにアタッチする必要があります。Meshを表示できるようにするためには、ゲームオブジェクトにはさらにMeshレンダラ あるいは他の適切なレンダラコンポーネントを持っている必要があります。これらのコンポーネントを使用することで、Meshはレンダラによって使用されるマテリアルどおりの外観で、ゲームオブジェクトの位置に表示されます。

Meshフィルター とMeshレンダラ でモデルを画面表示

UnityのMeshインポーターはMeshの生成を制御したり、テクスチャやマテリアルに関連付けるため、多くのオプションを用意しています。これらのオプションは、次のページで説明されています。

• 3Dフォーマット

3D-formats

Unityにメッシュをインポートするには主に2つのファイルからできます：

1. エクスポートされた3Dファイルフォーマット。例えば .FBX あるいは .OBJ
2. 3Dアプリケーションの専用ファイル、たとえば.Max または .Blendなど3D Studio Maxか、Blenderのファイル形式をサポートします。

どちらでもUnityにメッシュに取り込むことができますが、どちらを選ぶかにあたって考慮事項があります。

エクスポートされた3Dファイル形式

Unityは.FBX 、.dae (Collada)、.3DS、.dxf および.obj、FBXエクスポータファイルを読み込むことができ、FBXエクスポータはここ 多くのアプリケーションでobjやColladaのエクスポータを見つけることが出来ます。

長所

• 　必要なデータのみエクスポート
• 　検証可能なデータ（Unityに持っていく前に3Dパッケージに再インポートできます）
• 　一般的にファイルサイズが小さい
• 　モジュール単位のアプローチを推進できる（例． Collisionの型や相互関係性ごとにことなるコンポーネント）
• 　直接サポートしていないその他の3Dパッケージで独自形式があっても、この形式にすればサポートできます

短所

• 　プロトタイプや反復作業としては時間のかかるパイプラインとなります
• 　ソース（作業ファイル）とゲームデータ（例えば、FBXでエクスポート）の間のバージョン管理を見失いないがちになります

独自の3Dアプリケーションファイル形式

Unityが変換を通してインポートできるファイル形式: Max、 Maya、Blender、Cinema4D、Modo、Lightwave、Cheetah3D、たとえば.MAX、.MB、.MAなど

長所

• 　反復作業の時間がかからない（ソースファイルを保存すればUnityが自動で再インポート）
• 　最初の作業がシンプル

短所

• 　Unityプロジェクトを使用しているすべてのマシンに当該ソフトウェアのライセンスをインストールする必要があります
• 　ファイルは、不要なデータにより肥大化することがありえます
• 　容量の大きいファイルはUnityの更新を遅らせます
• 　検証が少ないデータ （問題のトラブルシューティングが困難）

Animations (Legacy)

Unity's Animation System allows you to create beautifully animated skinned characters. The Animation System supports animation blending, mixing, additive animations, walk cycle time synchronization, animation layers, control over all aspects of the animation playback (time, speed, blend-weights), mesh skinning with 1, 2 or 4 bones per vertex and finally physically based ragdolls.

For best practices on creating a rigged character with optimal performance in Unity, we recommended that you check out the section on Modeling Optimized Characters.

The following topics are covered on this page:

• Importing Character Animations
  • Inverse Kinematics
  • Adding animations to models that do not contain them
• Inserting Into a Unity Scene

Importing Animations

Spliting animations

Importing Inverse Kinematics

When importing animated characters from Maya that are created using IK, you have to check the Bake IK & simulation box in the Import Settings. Otherwise, your character will not animate correctly.

Bringing the character into the Scene

When you have imported your model you drag the object from the Project View into the Scene View or Hierarchy View

The animated character is added by dragging it into the scene

The character above has three animations in the animation list and no default animation. You can add more animations to the character by dragging animation clips from the Project View on to the character (in either the Hierarchy or Scene View). This will also set the default animation. When you hit Play, the default animation will be played.

Materials

There is a close relationship between Materials and Shaders in Unity. Shaders contain code that defines what kind of properties and assets to use. Materials allow you to adjust properties and assign assets.

A Shader is implemented through a Material

To create a new Material, use Assets->Create->Material from the main menu or the Project View context menu. Once the Material has been created, you can apply it to an object and tweak all of its properties in the Inspector. To apply it to an object, just drag it from the Project View to any object in the Scene or Hierarchy.

Setting Material Properties

You can select which Shader you want any particular Material to use. Simply expand the Shader drop-down in the Inspector, and choose your new Shader. The Shader you choose will dictate the available properties to change. The properties can be colors, sliders, textures, numbers, or vectors. If you have applied the Material to an active object in the Scene, you will see your property changes applied to the object in real-time.

There are two ways to apply a Texture to a property.

1. Drag it from the Project View on top of the Texture square
2. Click the Select button, and choose the texture from the drop-down list that appears

Two placement options are available for each Texture:

Built-in Shaders

There is a library of built-in Shaders that come standard with every installation of Unity. There are over 30 of these built-in Shaders, and six basic families.

• Normal: For opaque textured objects.
• Transparent: For partly transparent objects. The texture's alpha channel defines the level of transparency.
• TransparentCutOut: For objects that have only fully opaque and fully transparent areas, like fences.
• Self-Illuminated: For objects that have light emitting parts.
• Reflective: For opaque textured objects that reflect an environment Cubemap.

In each group, built-in shaders range by complexity, from the simple VertexLit to the complex Parallax Bumped with Specular. For more information about performance of Shaders, please read the built-in Shader performance page

This grid displays a thumbnail of all built-in Shaders:

The builtin Unity shaders matrix

Shader technical details

Unity has an extensive Shader system, allowing you to tweak the look of all in-game graphics. It works like this:

A Shader basically defines a formula for how the in-game shading should look. Within any given Shader is a number of properties (typically textures). Shaders are implemented through Materials, which are attached directly to individual GameObjects. Within a Material, you will choose a Shader, then define the properties (usually textures and colors, but properties can vary) that are used by the Shader.

This is rather complex, so let's look at a workflow diagram:

On the left side of the graph is the Carbody Shader. 2 different Materials are created from this: Blue car Material and Red car Material. Each of these Materials have 2 textures assigned; the Car Texture defines the main texture of the car, and a Color FX texture. These properties are used by the shader to make the car finish look like 2-tone paint. This can be seen on the front of the red car: it is yellow where it faces the camera and then fades towards purple as the angle increases. The car materials are attached to the 2 cars. The car wheels, lights and windows don't have the color change effect, and must hence use a different Material. At the bottom of the graph there is a Simple Metal Shader. The Wheel Material is using this Shader. Note that even though the same Car Texture is reused here, the end result is quite different from the car body, as the Shader used in the Material is different.

To be more specific, a Shader defines:

• The method to render an object. This includes using different methods depending on the graphics card of the end user.
• Any vertex and fragment programs used to render.
• Some texture properties that are assignable within Materials.
• Color and number settings that are assignable within Materials.

A Material defines:

• Which textures to use for rendering.
• Which colors to use for rendering.
• Any other assets, such as a Cubemap that is required by the shader for rendering.

Shaders are meant to be written by graphics programmers. They are created using the ShaderLab language, which is quite simple. However, getting a shader to work well on a variety graphics cards is an involved job and requires a fairly comprehensive knowledge of how graphics cards work.

A number of shaders are built into Unity directly, and some more come in the Standard Assets Library. If you like, there is plenty more shader information in the Built-in Shader Guide.

Textures

テクスチャ 2D

Texture により、Mesh、Particle やインターフェースがより活気付きます。 これらは重ねたり、オブジェクト周辺にラップする画像やムービー ファイルになります。 これらは非常に重要であるため、多くのプロパティを有しています。 初めてこれをレンダリングする場合は、Details に移動し、参照が必要な場合は、実際の設定に戻ります。

オブジェクトに使用するシェーダが必要なテクスチャに関する要件を追加しますが、画像ファイルをプロジェクト内に置くことができるということが基本的な原理です。 サイズ要件 (以下に記載) を満たすと、インポートされ、ゲームでの使用向けに最適化されます。 これにより、マルチ レイヤー Photoshop または TIFF ファイルに拡張され、インポート時に平坦化されるため、ゲームに対するサイズのペナルティはありません。

プロパティ

Texture Inspector は、その他ほとんどのものと見た目が若干ことなります。

上の部分には幾つかの設定が、下の部分には、Texture Importer とテクスチャ プレビューが含まれます。

テクスチャ インポータ

テクスチャはすべて Project Folder 内の画像からきます。 どのようにインポートされるかは、Texture Importer によって指定されます。 Project View でファイル テクスチャを選択し、Inspector で Import Settings を編集することで、テクスチャを変更します。

インスペクタの最上位にあるアイテムがTexture Type メニューでありソース画像ファイルから作成するテクスチャのタイプを選択できます。

「選択された基本テクスチャ設定」

テクスチャインポータの法線マッピング設定

「テクスチャ インポータの GUI 設定」

テクスチャインポータのCursor設定

「テクスチャ インポータの反射設定」

制御するのにグレースケール テクスチャを使用する方法です。 これは、移動する雲の作成や、密集する葉の印象を与えるのに便利です。 Light ページにこれに関する詳細が全て記載されていますが、テクスチャを使用可能にするには、Texture Type を「Cookie」に設定する必要があります。

「テクスチャ インポータの Cookie 設定」

「テクスチャインポータでのライトマップ設定」

「詳細テクスチャ インポータ設定ダイアログ」

プラットフォームごとの無効化

異なるプラットフォームを作成する場合、対象のプラットフォームに対するテクスチャの解像度やサイズ、画質を考慮する必要があります。 これらのオプションをデフォルト設定にしつつ、特定のプラットフォームで特定の値を割当てることができます。

「すべてのプラットフォーム用のデフォルト設定」

Texture Type を Advanced に設定している場合、Texture Format は異なる値になります。

デスクトップ

iOS

Android

Flash

詳細

対応形式

Unity は、次の画像ファイル形式をサポートしています。 PSD、TIFF、JPG、TGA、PNG、GIF、BMP、IFF、PICT。 Unity はマルチ レイヤー PSD & TIFF ファイルを適切にインポートできます。 これらはインポート時に自動的に平坦化されますが、レイヤーは、それ自体アセットに維持されるため。これらのファイルタイプをネイティブに使用する際も作業が無駄になることはありません。 これは、Photoshop から使用できるテクスチャのコピーの １ つを 3D モデリング アプリケーションから Unity に作成できるので重要です。

テクスチャ サイズ

理想的には、テクスチャは両側が 2 のべき乗になります。 これらのサイズは次のようになります。 2、4、8、16、32、64、128、256、512、1024 または 2048 ピクセル。 テクスチャは正方形である必要はありません。つまる、幅と高さは異なっていても構いません。

Unity では別のテクスチャ サイズ (2 のべき乗以外) を使用することができます。 2 のべき乗以外のテクスチャ サイズは、GUI Textures で使用されるのがベストですが、他で使用される場合は、非圧縮の RGBA 32 ビット形式に変換されます。 つまり、このテクスチャ サイズは、ビデオ メモリ (PVRT (iOS)/DXT (デスクトップ) 圧縮テクスチャ) を使用するため、ロードやレンダリングにより時間がかかります (iOS モード時)。 一般に、2 のべき乗以外のサイズは GUI 目的にのみ使用します。

2 のべき乗以外のテクスチャ アセット、インポート設定に詳細テクスチャ タイプの「Non Power of 2」オプションを使用して、インポート時に拡大できます。 Unity は、要求に応じて、テクスチャの内容を縮小拡大し、ゲーム内では、このテクスチャの内容は他のテクスチャ同様動作するため、圧縮でき、非常に高速でロードされます。

2 のべき乗以外のテクスチャの潜在的な問題として、Unityが内部処理で2のべき乗のテクスチャに変換し、ストレッチ処理がわずかな画像の乱れを引き起こすことがあります。

UV マッピング

3D モデルに 2D テクスチャをマッピングすると、ある種のラッピングが行われます。 これは、UV mapping と呼ばれ、3D モデリング アプリケーションで行われます。 Unity 内で、Materials を使用して、テクスチャをスケールおよび移動させることができます。 法線および詳細マップのスケーリングは特に便利です。

ミップ マップ

ミップ マップは、徐々に縮小していく画像で、リアルタイムの 3D エンジンでのパフォーマンを最適化するのに使用されます。 カメラから遠くにあるオブジェクトは、より小さいテクスチャを使用します。 ミップ マップを使用することで、33% のメモリしか使用しませんが、使用しないと、大きなパフォーマンス損失が生じます。 必ずゲーム内のテクスチャにミップ マップを使用した方がよいでしょう。小型化されないテクスチャの場合が唯一の例外です。

法線マップ

法線マップは、ポリゴンの少ないモデルをより多くの細部を持っているように見せる場合に法線マップ シェーダがあるように見せる場合にに使用されます。 Unity は、RGB 画像として符号化された法線マップを使用します。 グレースケールの高さマップ画像から法線マップを生成するオプションもあります。

詳細マップ

地形を作成したい場合は、通常、メイン テクスチャを使用して、くさや岩、砂などのエリアがどこにあるかを示します。 地形が適切なサイズの場合、最終的にぼやけてしまいます。 メイン テクスチャが近づくに連れ、Detail textures は、細かい細部をフェードインすることでこの事実を隠します。

詳細テクスチャを描画時に、ニュートラルのグレーが非表示になり、白がメイン テクスチャを 2 倍明るく、黒がメイン テクスチャを完全な黒に見せます。

反射 (キューブ マップ)

反射マップにテクスチャを使用したい場合 (例：「Reflective」組み込みシェーダを使用)、Cubemap Textures を使用する必要があります。

異方性フィルタリング

異方性フィルタリングは、グレージング角から表示された時に、レンダリング費用をある程度犠牲にして画質を向上します (この費用は全体的にグラフィック カードに依存します)。 異方性レベルを上げるのは通常、地面および床テクスチャにとってよいアイディアです。 Quality Settings では、異方性フィルタリングは、すべてのテクスチャに強制的に実行できるか、全体的に無効にできます。

「地面テクスチャに使用される非異方性 (左)/最大異方性(右)」

Procedural Materials

Unity incorporates a new asset type known as Procedural Materials. These are essentially the same as standard Materials except that the textures they use can be generated at runtime rather than being predefined and stored.

The script code that generates a texture procedurally will typically take up much less space in storage and transmission than a bitmap image and so Procedural Materials can help reduce download times. Additionally, the generation script can be equipped with parameters that can be changed in order to vary the visual properties of the material at runtime. These properties can be anything from color variations to the size of bricks in a wall. Not only does this mean that many variations can be generated from a single Procedural Material but also that the material can be animated on a frame-by-frame basis. Many interesting visual effects are possible - imagine a character gradually turning to stone or acid damaging a surface as it touches.

Unity's Procedural Material system is based around an industry standard product called Substance, developed by Allegorithmic

Supported Platforms

In Unity, Procedural Materials are fully supported for standalone and webplayer build targets only (Windows and Mac OS X). For all other platforms, Unity will pre-render or bake them into ordinary Materials during the build. Although this clearly negates the runtime benefits of procedural generation, it is still useful to be able to create variations on a basic material in the editor.

Adding Procedural Materials to a Project

A Procedural Material is supplied as a Substance Archive file (SBSAR) which you can import like any other asset (drag and drop directly onto the Assets folder or use Assets->Import New Asset...). A Substance Archive asset contains one or more Procedural Materials and contains all the scripts and images required by these. Uncompiled SBS files are not supported.

Although they are implemented differently, Unity handles a Procedural Material just like any other Material. To assign a Procedural Material to a mesh, for example, you just drag and drop it onto the mesh exactly as you would with any other Material.

Procedural Properties

Each Procedural Material is a custom script which generates a particular type of material. These scripts are similar to Unity scripts in that they can have variables exposed for assignment in the inspector. For example, a "Brick Wall" Procedural Material could expose properties that let you set the number of courses of bricks, the colors of the bricks and the color of the mortar. This potentially offers infinite material variations from a single asset. These properties can also be set from a script at runtime in much the same way as the public variables of a MonoBehaviour script.

Procedural Materials can also incorporate complex texture animation. For example, you could animate the hands of the clock or cockroaches running across a floor.

Creating Procedural Materials From Scratch

Procedural Materials can work with any combination of procedurally generated textures and stored bitmaps. Additionally, included bitmap images can be filtered and modified before use. Unlike a standard Material, a Procedural Material can use vector images in the form of SVG files which allows for resolution-independent textures.

The design tools available for creating Procedural Materials from scratch use visual, node-based editing similar to the kind found in artistic tools. This makes creation accessible to artists who may have little or no coding experience. As an example, here is a screenshot from Allegorithmic's Substance Designer which shows a "brick wall" Procedural Material under construction:

Obtaining Procedural Materials

Since Unity's Procedural Materials are based on the industry standard Substance product, Procedural Material assets are readily available from internet sources, including Unity's own Asset Store. Allegorithmic's Substance Designer can be used to create Procedural Materials, but there are other applications (3D modelling apps, for example) that incorporate the Substance technology and work just as well with Unity.

Performance and Optimization

Procedural Materials inherently tend to use less storage than bitmap images. However, the trade-off is that they are based around scripts and running those scripts to generate materials requires some CPU and GPU resources. The more complex your Procedural Materials are, the greater their runtime overhead.

Procedural Materials support a form of caching whereby the material is only updated if its parameters have changed since it was last generated. Further to this, some materials may have many properties that could theoretically be changed and yet only a few will ever need to change at runtime. In such cases, you can inform Unity about the variables that will not change to help it cache as much data as possible from the previous generation of the material. This will often improve performance significantly.

Procedural Materials can also be used purely as a convenience in the editor (ie, you can generate a standard Material by setting the parameters of a Procedural Material and then "baking" it). This will remove the runtime overhead of material generation but naturally, the baked materials can't be changed or animated during gameplay.

Using the Substance Player to Analyze Performance

Since the complexity of a Procedural Material can affect runtime performance, Allegorithmic incorporates profiling features in its Substance Player tool. This tool is available to download for free from Allegorithmic's website.

Substance Player uses the same optimized rendering engine as the one integrated into Unity, so its rendering measurement is more representative of performance in Unity than that of Substance Designer.

Video Files

注意：　Unity Pro/ Advancedのみ

デスクトップ!

Movie Texturesは、ビデオファイルから作成され、アニメーション化されたTextureです。

プロジェクトのAssetsフォルダに動画ファイルを配置することによって、通常使用するTexture とまったく同じように使用できるビデオをインポートすることができます。

動画ファイルはApple社のQuickTimeを介してインポートされます。サポートされるファイルの種類はインストールされたQuickTimeのがサポートするものと一致します（通常は .mov、 .mpg、 .mpeg、 .mp4、 .avi、 .asf）Windows上でムービーがインポートされるためにはQuickTimeがインストールされていることが必要です（(ここ )　からダウンロード）

プロパティ

Movie Textures　Inspectorは、通常のTexture Inspectorと非常によく似ています。

Unity上でビデオファイルから生成したMovie Textures

Aniso Level	急な角度から眺めたときのTexture品質を向上させます。床や地面のTextureに良い。
Filter Mode	Textureが3Dへの変換によりストレッチされたときのフィルタ処理を選択
Loop	オンの時、ムービー再生終了後にループ
Quality	Ogg Theoraビデオファイルの圧縮。より高い値により、品質がより高い一方でファイルサイズは大きくなる。

詳細

ビデオファイルがプロジェクトに追加されると、自動的にインポートされ、Ogg Theora形式に変換されます。一度Movie Texturesがインポートすると、通常のTextureのように、任意のGameObjectまたはMaterialにアタッチできます。

ムービーを再生

ゲームの実行開始時に、Movie Texturesは自動再生されません。再生を指示するスクリプトを準備する必要があります。

// このコードによりMovie Texturesが再生されます
renderer.material.mainTexture.Play();

スペースが押されたときに動画再生をプレイバックに切り替えるためには、次のスクリプトをアタッチします。

function Update () {
	if (Input.GetButtonDown ("Jump")) {
		if (renderer.material.mainTexture.isPlaying) {
			renderer.material.mainTexture.Pause();
		}
		else {
			renderer.material.mainTexture.Play();
		}
	}
}

Movie Texturesを再生する方法の詳細については、Movie Textures スクリプトリファレンス を参照してください。

ムービーオーディオ

Movie Texturesをインポートすると、映像とともにオーディオトラックもインポートされます。オーディオは、Movie TexturesのAudioClipを子オブジェクトとして表示されます。

ビデオのオーディオトラックはProject ViewにてMovie Texturesの子オブジェクトとして表示されます

このオーディオを再生するには、他のオーディオクリップのように、ゲームオブジェクトにアタッチする必要があります。Project Viewから、シーンビューか階層ビューの任意のゲームオブジェクトへドラッグします。

通常、ムービーを見せているのと同じゲームオブジェクトになります。次に audio.Play() を使用し、映像に合わせてオーディオトラックを再生します。

iOS

Android

Audio Files

As with Meshes or Textures, the workflow for Audio File assets is designed to be smooth and trouble free. Unity can import almost every common file format but there are a few details that are useful to be aware of when working with Audio Files.

Audio in Unity is either Native or Compressed. Unity supports most common formats (see the list below) and will import an audio file when it is added to the project. The default mode is Native, where the audio data from the original file is imported unchanged. However, Unity can also compress the audio data on import, simply by enabling the Compressed option in the importer. (iOS projects can make use of the hardware decoder - see the iOS documentation for further details). The difference between Native and Compressed modes are as follows:-

• Native: Use Native (WAV, AIFF) audio for short sound effects. The audio data will be larger but sounds won't need to be decoded at runtime.
• Compressed: The audio data will be small but will need to be decompressed at runtime, which entails a processing overhead. Depending on the target, Unity will encode the audio to either Ogg Vorbis(Mac/PC/Consoles) or MP3 (Mobile platforms). For the best sound quality, supply the audio in an uncompressed format such as WAV or AIFF (containing PCM data) and let Unity do the encoding. If you are targeting Mac and PC platforms only (including both standalones and webplayers) then importing an Ogg Vorbis file will not degrade the quality. However, on mobile platforms, Ogg Vorbis and MP3 files will be re-encoded to MP3 on import, which will introduce a slight quality degradation.

Any Audio File imported into Unity is available from scripts as an Audio Clip instance, which is effectively just a container for the audio data. The clips must be used in conjunction with Audio Sources and an Audio Listener in order to actually generate sound. When you attach your clip to an object in the game, it adds an Audio Source component to the object, which has Volume, Pitch and a numerous other properties. While a Source is playing, an Audio Listener can "hear" all sources within range, and the combination of those sources gives the sound that will actually be heard through the speakers. There can be only one Audio Listener in your scene, and this is usually attached to the Main Camera.

Supported Formats

See the Sound chapter in the Creating Gameplay section of this manual for more information on using sound in Unity.

オーディオ クリップ

Audio Clip は、Audio Source によって使用されるオーディオ データです。 Unity は、モノ、ステレオおよびマルチ チャンネル （8 つまで） のオーディオ アセットをサポートしています。 Unity は、次のオーディオ ファイル形式をサポートしています。 .aif、.wav、.mp3、 .oggおよび次の トラッカー モジュール ファイル形式: .xm、.mod、.itおよび .s3m 。 トラッカー モジュール アセットは、波形プレビューをアセット インポート インスペクタにレンダリングできないこと以外は、Unity のその他のオーディオ アセットと同じ働きをします。

「オーディオ クリップ Inspector」

プロパティ

オーディオ アセットのインポート

Unity は「圧縮」と「ネイティブ」オーディオの両方をサポートしています。 どのファイルも （MP3/Ogg Vorbis を除く） 最初は「ネイティブ」としてインポートされます。 ゲーム稼働中、圧縮オーディオ ファイルは CPU　によって解凍される必要がありますが、ファイル サイズは小さくなります。 「Stream」にチェックを入れると、オーディオは「オン ザ フライ」で解凍されるか、そうでない場合は、オーディオはロード時に全体的に解凍されます。 ネイティブの PCM 形式 （WAV、AIFF） には CPU への負担を増やすことなく、高い忠実性があるという利点がありますが、作成されるファイルのサイズははるかに大きくなります。 モジュール ファイル （.mod、.it、.s3m..xm） は、極めて低いフットプリントで非常に高い音質を提供できます。

一般的に、「圧縮」オーディオ （またはモジュール） は、BGM や会話などの長いファイルに最適で、非圧縮オーディオは、短い音響効果により適しています。 高圧縮から始めて、圧縮スライダで圧縮の量を弱め、音質の差が著しくなる前後で適切に微調整します。

3D オーディオの使用

オーディオ クリップに「3D 音声」と表示されている場合、このクリップは、ゲームの世界の 3D　スペースでの位置をシミュレートするために再生されます。 3D　音声は、音量を減らし、スピーカー間でパンすることで、音声の距離や位置をエミュレートします。 モノとマルチ チャンネルの音声の両方を 3D に配置できます。 マルチ チャンネル オーディオの場合、Audio Source の「Spread」オプションを使用して、スピーカー スペースで個々のチャンネルを拡散および分割します。 Unity は、3D スペースでのオーディオ の動作を制御および微調整するための各種オプションを提供しています。 Audio Source を参照してください。

プラットフォーム固有の詳細

iOS

Android

TrackerModules

Tracker Modules are essentially just packages of audio samples that have been modeled, arranged and sequenced programatically. The concept was introduced in the 1980's (mainly in conjunction with the Amiga computer) and has been popular since the early days of game development and demo culture.

Tracker Module files are similar to MIDI files in many ways. The tracks are scores that contain information about when to play the instruments, and at what pitch and volume and from this, the melody and rhythm of the original tune can be recreated. However, MIDI has a disadvantage in that the sounds are dependent on the sound bank available in the audio hardware, so MIDI music can sound different on different computers. In contrast, tracker modules include high quality PCM samples that ensure a similar experience regardless of the audio hardware in use.

Supported formats

Unity supports the four most common module file formats, namely Impulse Tracker (.it), Scream Tracker (.s3m), Extended Module File Format (.xm), and the original Module File Format (.mod).

Benefits of Using Tracker Modules

Tracker module files differ from mainstream PCM formats (.aif, .wav, .mp3, and .ogg) in that they can be very small without a corresponding loss of sound quality. A single sound sample can be modified in pitch and volume (and can have other effects applied), so it essentially acts as an "instrument" which can play a tune without the overhead of recording the whole tune as a sample. As a result, tracker modules lend themselves to games, where music is required but where a large file download would be a problem.

Third Party Tools and Further References

Currently, the most popular tools to create and edit Tracker Modules are MilkyTracker for OSX and OpenMPT for Windows. For more information and discussion, please see the blog post .mod in Unity from June 2010.

Scripting

This brief introduction explains how to create and use scripts in a project. For detailed information about the Scripting API, please view the Scripting Reference. For detailed information about creating game play through scripting, please view the Creating Gameplay page of this manual.

Behaviour scripts in Unity can be written in JavaScript, C#, or Boo. It is possible to use any combination of the three languages in a single project, although there are certain restrictions in cases where one script incorporates classes defined in another script.

Creating New Scripts

Unlike other assets like Meshes or Textures, Script files can be created from within Unity. To create a new script, open the Assets->Create->JavaScript (or Assets->Create->C Sharp Script or Assets->Create->Boo Script) from the main menu. This will create a new script called NewBehaviourScript and place it in the selected folder in Project View. If no folder is selected in Project View, the script will be created at the root level.

You can edit the script by double-clicking on it in the Project View. This will launch your default text editor as specified in Unity's preferences. To set the default script editor, change the drop-down item in Unity->Preferences->External Script editor.

These are the contents of a new, empty behaviour script:

function Update () {
} 

A new, empty script does not do a lot on its own, so let's add some functionality. Change the script to read the following:

function Update () {
    print("Hello World");
} 

When executed, this code will print "Hello World" to the console. But there is nothing that causes the code to be executed yet. We have to attach the script to an active GameObject in the Scene before it will be executed.

Attaching scripts to objects

Save the above script and create a new object in the Scene by selecting GameObject->Create Other->Cube. This will create a new GameObject called "Cube" in the current Scene.

Now drag the script from the Project View to the Cube (in the Scene or Hierarchy View, it doesn't matter). You can also select the Cube and choose Component->Scripts->New Behaviour Script. Either of these methods will attach the script to the Cube. Every script you create will appear in the Component->Scripts menu.

If you select the Cube and look at the Inspector, you will see that the script is now visible. This means it has been attached.

Press Play to test your creation. You should see the text "Hello World" appear beside the Play/Pause/Step buttons. Exit play mode when you see it.

Manipulating the GameObject

A print() statement can be very handy when debugging your script, but it does not manipulate the GameObject it is attached to. Let's change the script to add some functionality:

function Update () {
    transform.Rotate(0, 5*Time.deltaTime, 0);
} 

If you're new to scripting, it's okay if this looks confusing. These are the important concepts to understand:

1. function Update () {} is a container for code that Unity executes multiple times per second (once per frame).
2. transform is a reference to the GameObject's Transform Component.
3. Rotate() is a function contained in the Transform Component.
4. The numbers in-between the commas represent the degrees of rotation around each axis of 3D space: X, Y, and Z.
5. Time.deltaTime is a member of the Time class that evens out movement over one second, so the cube will rotate at the same speed no matter how many frames per second your machine is rendering. Therefore, 5 * Time.deltaTime means 5 degrees per second.

With all this in mind, we can read this code as "every frame, rotate this GameObject's Transform component a small amount so that it will equal five degrees around the Y axis each second."

You can access lots of different Components the same way as we accessed transform already. You have to add Components to the GameObject using the Component menu. All the Components you can access directly are listed under Variables on the GameObject Scripting Reference Page.

For more information about the relationship between GameObjects, Scripts, and Components, please jump ahead to the GameObjects page or Using Components page of this manual.

The Power of Variables

Our script so far will always rotate the Cube 5 degrees each second. We might want it to rotate a different number of degrees per second. We could change the number and save, but then we have to wait for the script to be recompiled and we have to enter Play mode before we see the results. There is a much faster way to do it. We can experiment with the speed of rotation in real-time during Play mode, and it's easy to do.

Instead of typing 5 into the Rotate() function, we will declare a speed variable and use that in the function. Change the script to the following code and save it:

var speed = 5.0;

function Update () {
    transform.Rotate(0, speed*Time.deltaTime, 0);
}

Now, select the Cube and look at the Inspector. Notice how our speed variable appears.

This variable can now be modified directly in the Inspector. Select it, press Return and change the value. You can also right- or option-click on the value and drag the mouse up or down. You can change the variable at any time, even while the game is running.

Hit Play and try modifying the speed value. The Cube's rotation speed will change instantly. When you exit Play mode, you'll see that your changes are reverted back to their value before entering Play mode. This way you can play, adjust, and experiment to find the best value, then apply that value permanently.

The technique of changing a variable's value in the Inspector makes it easy to reuse one script on many objects, each with a different variable value. If you attach the script to multiple Cubes, and change the speed of each cube, they will all rotate at different speeds even though they use the same script.

Accessing Other Components

When writing a script Component, you can access other components on the GameObject from within that script.

Using the GameObject members

You can directly access any member of the GameObject class. You can see a list of all the GameObject class members here. If any of the indicated classes are attached to the GameObject as a Component, you can access that Component directly through the script by simply typing the member name. For example, typing transform is equivalent to gameObject.transform. The gameObject is assumed by the compiler, unless you specifically reference a different GameObject.

Typing this will be accessing the script Component that you are writing. Typing this.gameObject is referring to the GameObject that the script is attached to. You can access the same GameObject by simply typing gameObject. Logically, typing this.transform is the same as typing transform. If you want to access a Component that is not included as a GameObject member, you have to use gameObject.GetComponent() which is explained on the next page.

There are many Components that can be directly accessed in any script. For example, if you want to access the Translate function of the Transform component, you can just write transform.Translate() or gameObject.transform.Translate(). This works because all scripts are attached to a GameObject. So when you write transform you are implicitly accessing the Transform Component of the GameObject that is being scripted. To be explicit, you write gameObject.transform. There is no advantage in one method over the other, it's all a matter of preference for the scripter.

To see a list of all the Components you can access implicitly, take a look at the GameObject page in the Scripting Reference.

Using GetComponent()

There are many Components which are not referenced directly as members of the GameObject class. So you cannot access them implicitly, you have to access them explicitly. You do this by calling the GetComponent("component name") and storing a reference to the result. This is most common when you want to make a reference to another script attached to the GameObject.

Pretend you are writing Script B and you want to make a reference to Script A, which is attached to the same GameObject. You would have to use GetComponent() to make this reference. In Script B, you would simply write:

scriptA = GetComponent("ScriptA");

For more help with using GetComponent(), take a look at the GetComponent() Script Reference page.

Accessing variables in other script Components

All scripts attached to your GameObjects are Components. Therefore to get access to a public variable (and methods) in a script you make use of the GetComponent method. For example:

function Start () {
   // Print the position of the transform component, for the gameObject this script is attached to
   Debug.Log(gameObject.GetComponent<Transform>.().position);
}

In the previous example the GetComponent<T>. function is used to access the position property of the Transform component. The same technique can be used to access a variable in a custom script Component:

(MyClass.js)
public var speed : float = 3.14159;

(MyOtherClass.js)
function Start () {
   // Print the speed variable from the MyClass script Component attached to the gameObject
   Debug.Log(gameObject.GetComponent<MyClass>.().speed);
}

Accessing a variable defined in C# from Javascript

To access variables defined in C# scripts the compiled Assembly containing the C# code must exist when the Javascript code is compiled. Unity performs the compilation in different stages as described in the Script Compilation section in the Scripting Reference. If you want to create a Javascript that uses classes or variables from a C# script just place the C# script in the "Standard Assets", "Pro Standard Assets" or "Plugins" folder and the Javascript outside of these folders. The code inside the "Standard Assets", "Pro Standard Assets" or "Plugins" is compiled first and the code outside is compiled in a later step making the Types defined in the compilation step (your C# script) available to later compilation steps (your Javascript script).

In general the code inside the "Standard Assets", "Pro Standard Assets" or "Plugins" folders, regardless of the language (C#, Javascript or Boo), will be compiled first and available to scripts in subsequent compilation steps.

Optimizing variable access

In some circumstances you may be using GetComponent multiple times in your code, or multiple times per frame. Every call to GetComponent does a few extra steps internally to get the reference to the component you require. A more efficient approach is to store the reference to the component for example in your Start() function. As you will be storing the reference and not retrieving directly it is always good practice to check for null references:

(MyClass.js)
public var speed : float = 3.14159;

(MyOtherClass.js)
private var myClass : MyClass;
function Start () {
   // Get a reference to the MyClass script Component attached to the gameObject
   myClass = gameObject.GetComponent<MyClass>.();
}
function Update () {
   // Verify that the reference is still valid and print the speed variable
   if(myClass != null)
      Debug.Log (myClass.speed);
}

Static Variables

It is also possible to declare variables in your classes as static. There will exist one and only one instance of a static variable for a specific class and it can be modified without the need of an instance of a class object:

(MyClass.js)
static public var speed : float = 3.14159;

(MyOtherClass.js)
function Start () {
   Debug.Log (MyClass.speed);
}

It is recommended to not use static variables for object references to make sure unused objects are removed from memory.

Where to go from here

This was just a short introduction on how to use scripts inside the Editor. For more examples, check out the Unity tutorials, available for free on our Asset Store. You should also read through the Scripting Overview in the Script Reference, which contains a more thorough introduction into scripting with Unity along with pointers to more in-depth information. If you're really stuck, be sure to visit the Unity Answers or Unity Forums and ask questions there. Someone is always willing to help.

Asset Store

Unity's Asset Store is home to a growing library of free and commercial assets created both by Unity Technologies and also members of the community. A wide variety of assets is available, covering everything from textures, models and animations to whole project examples, tutorials and Editor extensions. The assets are accessed from a simple interface built into the Unity Editor and are downloaded and imported directly into your project.

Access and Navigation

You can open the Asset Store window by selecting Window->AssetStore from the main menu. On your first visit, you will be prompted to create a free user account which you will use to access the Store subsequently.

The Asset Store front page.

The Store provides a browser-like interface which allows you to navigate either by free text search or by browsing packages and categories. To the left of the main tool bar are the familiar browsing buttons for navigating through the history of viewed items:-

To the right of these are buttons for viewing the Download Manager and for viewing the current contents of your shopping cart.

The Download Manager allows you to view the packages you have already bought and also to find and install any updates. Additionally, the standard packages supplied with Unity can be viewed and added to your project with the same interface.

The Download Manager.

Location of Downloaded Asset Files

You will rarely, if ever, need to access the files downloaded from the Asset Store directly. However, if you do need to, you can find them in

  ~/Library/Unity/Asset Store

...on the Mac and in

  C:\Users\accountName\AppData\Roaming\Unity\Asset Store

...on Windows. These folders contain subfolders that correspond to particular Asset Store vendors - the actual asset files are contained in the appropriate subfolders.

Asset Server

Unity Asset Server Overview

The Unity Asset Server is an asset and version control system with a graphical user interface integrated into Unity. It is meant to be used by team members working together on a project on different computers either in-person or remotely. The Asset Server is highly optimized for handling large binary assets in order to cope with large multi gigabyte project folders. When uploading assets, Import Settings and other meta data about each asset is uploaded to the asset server as well. Renaming and moving files is at the core of the system and well supported.

It is available only for Unity Pro, and is an additional license per client. To purchase an Asset Server Client License, please visit the Unity store at http://unity3d.com/store

New to Source Control?

If you have never used Source Control before, it can be a little unfriendly to get started with any versioning system. Source Control works by storing an entire collection of all your assets - meshes, textures, materials, scripts, and everything else - in a database on some kind of server. That server might be your home computer, the same one that you use to run Unity. It might be a different computer in your local network. It might be a remote machine colocated in a different part of the world. It could even be a virtual machine. There are a lot of options, but the location of the server doesn't matter at all. The important thing is that you can access it somehow over your network, and that it stores your game data.

In a way, the Asset Server functions as a backup of your Project Folder. You do not directly manipulate the contents of the Asset Server while you are developing. You make changes to your Project locally, then when you are done, you Commit Changes to the Project on the Server. This makes your local Project and the Asset Server Project identical.

Now, when your fellow developers make a change, the Asset Server is identical to their Project, but not yours. To synchronize your local Project, you request to Update from Server. Now, whatever changes your team members have made will be downloaded from the server to your local Project.

This is the basic workflow for using the Asset Server. In addition to this basic functionality, the Asset Server allows for rollback to previous versions of assets, detailed file comparison, merging two different scripts, resolving conflicts, and recovering deleted assets.

Setting up the Asset Server

The Asset Server requires a one time server setup and a client configuration for each user. You can read about how to do that in the Asset Server Setup page.

The rest of this guide explains how to deploy, administrate, and regularly use the Asset Server.

Daily use of the Asset Server

This section explains the common tasks, workflow and best practices for using the Asset Server on a day-to-day basis.

Getting Started

If you are joining a team that has a lot of work stored on the Asset Server already, this is the quickest way to get up and running correctly. If you are starting your own project from scratch, you can skip down to the Workflow Fundamentals section.

1. Create a new empty Project with no packages imported
2. Go to Edit->Project Settings->Editor and select Asset Server as the version control mode
3. From the menubar, select Window->Version
4. Click the Connection button
5. Enter your user name and password (provided by your Asset Server administrator)
6. Click Show Projects and select the desired project
7. Click Connect
8. Click the Update tab
9. Click the Update button
10. If a conflict occurs, discard all local versions
11. Wait for the update to complete
12. You are ready to go

Continue reading for detailed information on how to use the Asset Server effectively every day.

Workflow Fundamentals

When using the Asset Server with a multi-person team, it is generally good practice to Update all changed assets from the server when you begin working, and Commit your changes at the end of the day, or whenever you're done working. You should also commit changes when you have made significant progress on something, even if it is in the middle of the day. Committing your changes regularly and frequently is recommended.

Understanding the Server View

The Server View is your window into the Asset Server you're connected to. You can open the Server View by selecting Window->Version Control.

The Overview tab

The Server View is broken into tabs: Overview Update, and Commit. Overview will show you any differences between your local project and the latest version on the server with options to quickly commit local changes or download the latest updates. Update will show you the latest remote changes on the server and allow you to download them to your local project. Commit allows you to create a Changeset and commit it to the server for others to download.

Connecting to the server

Before you can use the asset server, you must connect to it. To do this you click the Connection button, which takes you to the connection screen:

The Asset Server connection screen

Here you need to fill in:

1. Server address
2. Username
3. Password

By clicking Show projects you can now see the available projects on the asset server, and choose which one to connect to by clicking Connect. Note that the username and password you use can be obtain from your system administrator. Your system administrator created accounts when they installed Asset Server.

Updating from the Server

To download all updates from the server, select the Update tab from the Overview tab and you will see a list of the latest committed Changesets. By selecting one of these you can see what was changed in the project as well as the provided commit message. Click Update and you will begin downloading all Changeset updates.

The Update Tab

Committing Changes to the Server

When you have made a change to your local project and you want to store those changes on the server, you use the top Commit tab.

The Commit tab

Now you will be able to see all the local changes made to the project since your last update, and will be able to select which changes you wish to upload to the server. You can add changes to the changeset either by manually dragging them into the changeset field, or by using the buttons placed below the commit message field. Remember to type in a commit message which will help you when you compare versions or revert to an earlier version later on, both of which are discussed below.

Resolving conflicts

With multiple people working on the same collection of data, conflicts will inevitably arise. Remember, there is no need to panic! If a conflict exists, you will be presented with the Conflict Resolution dialog when updating your project.

The Conflict Resolution screen

Here, you will be informed of each individual conflict, and be presented with different options to resolve each individual conflict. For any single conflict, you can select Skip Asset (which will not download that asset from the server), Discard My Changes (which will completely overwrite your local version of the asset) or Ignore Server Changes (which will ignore the changes others made to the asset and after this update you will be able to commit your local changes over server ones) for each individual conflict. Additionally, you can select Merge for text assets like scripts to merge the server version with the local version.

Note: If you choose to discard your changes, the asset will be updated to the latest version from the server (i.e., it will incorporate other users' changes that have been made while you were working). If you want to get the asset back as it was when you started working, you should revert to the specific version that you checked out. (See Browsing revision history and reverting assets below.)

If you run into a conflict while you are committing your local changes, Unity will refuse to commit your changes and inform you that a conflict exists. To resolve the conflicts, select Update. Your local changes will not automatically be overwritten. At this point you will see the Conflict Resolution dialog, and can follow the instructions in the above paragraph.

Browsing revision history and reverting assets

The Asset Server retains all uploaded versions of an asset in its database, so you can revert your local version to an earlier version at any time. You can either select to restore the entire project or single files. To revert to an older version of an asset or a project, select the Overview tab then click Show History listed under Asset Server Actions. You will now see a list of all commits and be able to select and restore any file or all project to an older version.

The History dialog

Here, you can see the version number and added comments with each version of the asset or project. This is one reason why descriptive comments are helpful. Select any asset to see its history or Entire Project for all changes made in project. Find revision you need. You can either select whole revision or particular asset in revision. Then click Download Selected File to get your local asset replaced with a copy of the selected revision. Revert All Project will revert entire project to selected revision.

Prior to reverting, if there are any differences between your local version and the selected server version, those changes will be lost when the local version is reverted.

If you only want to abandon the changes made to the local copy, you don't have to revert. You can discard those local modifications by selecting Discard Changes in the main asset server window. This will immediately download the current version of the project from the server to your local Project.

Comparing asset versions

If you're curious to see the differences between two particular versions you can explicitly compare them. To do this, open History window, select revision and asset you want to compare and press Compare to Local Version. If you need to compare two different revisions of an asset - right click on it, in the context menu select Compare to Another Revision then find revision you want to compare to and select it.

Note: this feature requires that you have one of supported file diff/merge tools installed. Supported tools are:

• On Windows:
  • TortoiseMerge: part of TortoiseSVN or a separate download from the project site.
  • WinMerge.
  • SourceGear Diff/Merge.
  • Perforce Merge (p4merge): part of Perforce's visual client suite (P4V).
  • TkDiff.
• On Mac OS X:
  • SourceGear Diff/Merge.
  • FileMerge: part of Apple's XCode development tools.
  • TkDiff.
  • Perforce Merge (p4merge): part of Perforce's visual client suite (P4V).

Recovering deleted assets

Deleting a local asset and committing the delete to the server will in fact not delete an asset permanently. Just as any previous version of an asset can be restored through History window from the Overview tab.

The History dialog

Expand Deleted Assets item, find and select assets from the list and hit Recover, the selected assets will be downloaded and re-added to the local project. If the folder that the asset was located in before the deletion still exists, the asset will be restored to the original location, otherwise it will be added to the root of the Assets folder in the local project.

Best Practices & Common Issues

This is a compilation of best practices and solutions to problems which will help you when using the Asset Server:

1. Backup, Backup, Backup
   • Maintain a backup of your database. It is very important to do this. In the unfortunate case that you have a hardware problem, a virus, a user error, etc you may loose all of your work. Therefore make sure you have a backup system in place. You can find lots of resources online for setting up backup systems.
2. Stop the server before shutting the machine down
   • This can prevent "fast shutdowns" from being generated in the PostgreSQL (Asset Server) log. If this occurs the Asset Server has to do a recovery due to an improper shut down. This can take a very long time if you have a large project with many commits.
3. Resetting you password from Console
   • You can reset your password directly from a shell, console or command line using the following command:
     
     psql -U unitysrv -d template1 -c"alter role admin with password 'MYPASSWORD'"
4. Can't connect to Asset Server
   • The password may have expired. Try resetting your password.
   • Also the username is case sensitive: "Admin" != "admin". Make sure you are using the correct case.
   • Make sure the server is actually running:
     • On OS X or Linux you can type on the terminal: ps -aux
     • On Windows you can use the Task Manager.
   • Verify that the Asset Server is not running on more than one computer in your Network. You could be connecting to the wrong one.
5. The Asset Server doesn't work in 64-bit Linux
   • The asset server can run OK on 64-bit Linux machines if you install 32-bit versions of the required packages. You can use "dpkg -i --force-architecture" to do this.
6. Use the Asset Server logs to get more information
   • Windows:
     • \Unity\AssetServer\log
   • OS X:
     • /Library/UnityAssetServer/log

Asset Server training complete

You should now be equipped with the knowledge you need to start using the Asset Server effectively. Get to it, and don't forget the good workflow fundamentals. Commit changes often, and don't be afraid of losing anything.

Asset Cache Server

Unity has a completely automatic asset pipeline. Whenever a source asset like a .psd or an .fbx file is modified, Unity will detect the change and automatically reimport it. The imported data from the file is subsequently stored by Unity in its own internal format. The best parts about the asset pipeline are the "hot reloading" functionality and the guarantee that all your source assets are always in sync with what you see. This feature also comes at a cost. Any asset that is modified has to be reimported right away. When working in large teams, after getting latest from Source Control, you often have to wait for a long time to re-import all the assets modified or created by other team members. Also, switching your project platform back and forth between desktop and mobile will trigger a re-import of most assets.

The time it takes to import assets can be drastically reduced by caching the imported asset data on the Cache Server.

Each asset import is cached based on

• The asset file itself
• The import settings
• Asset importer version
• The current platform.

If any of the above change, the asset gets reimported, otherwise it gets downloaded from the Cache Server.

When you enable the cache server in the preferences, you can even share asset imports across multiple projects.

Note that once the cache server is set up, this process is completely automatic, which means there are no additional workflow requirements. It will simply reduce the time it takes to import projects without getting in your way.

How to set up a Cache Server (user)

Setting up the Cache Server couldn't be easier. All you need to do is click Use Cache Server in the preferences and tell the local machine's Unity Editor where the Cache Server is.

This can be found in Unity->Preferences on the Mac or Edit->Preferences on the PC.

If you are hosting the Cache Server on your local machine, specify localhost for the server address. However, due to hard drive size limitations, it is recommended you host the Cache Server on separate machine.

How to set up a Cache Server (admin)

Admins need to set up the Cache Server machine that will host the cached assets.

You need to:

• Download the Cache Server here
• Unzip the file, after which you should see something like this:

• Depending on your operating system, run the appropriate command script.
• You will see a terminal window, indicating that the Cache Server is running in the background

The Cache Server needs to be on a reliable machine with very large storage (much larger than the size of the project itself, as there will likely be multiple versions of imported resources stored). If the hard disk becomes full the Cache Server could perform slowly.

Installing the Cache Server as a service

The provided .sh and .cmd scripts should be set-up as a service on the server. The cache server can be safely killed and restarted at any time, since it uses atomic file operations.

Cache Server Configuration

If you simply start the Cache Server by double clicking the script, it will create a "cache" directory next to the script, and keep its data in there. The cache directory is allowed to grow to up to 50 GB. You can configure the size and the location of the data using command line options, like this:

./RunOSX.command --path ~/mycachePath --size 2000000000

--path lets you specify a cache location, and --size lets you specify the maximum cache size in bytes.

Recommendations for the machine hosting the Cache Server

We recommend equipping the machine with a lot of RAM. For best performance there is enough RAM to hold an entire imported project folder. In addition, it is best to have a machine with a fast hard drive and fast Ethernet connection. The hard drive should also have sufficient free space. On the other hand, the Cache Server has very low CPU usage.

One of the main distinctions between the Cache Server and version control is that its cached data can always be rebuilt locally. It is simply a tool for improving performance. For this reason it doesn't make sense to use a Cache Server over the Internet. If you have a distributed team, we recommend that you place a separate cache server in each location.

We recommend that you run the cache server on a Linux or Mac OS X machine. The Windows file system is not particularly well optimized for how the Asset Cache Server stores data and problems with file locking on Windows can cause issues that don't occur on Linux or Mac OS X.

Cache Server FAQ

Will the size of my Cache Server database grow indefinitely as more and more resources get imported and stored?

The Cache Server removes assets that have not been used for a period of time automatically (of course if those assets are needed again, they will be re-created during next usage).

Does the cache server work only with the asset server?

The cache server is designed to be transparent to source/version control systems and so you are not restricted to using Unity's asset server.

What changes will cause the imported file to get regenerated?

When Unity is about to import an asset, it generates an MD5 hash of all source data.

For a texture this consists of:

• The source asset: "myTexture.psd" file
• The meta file: "myTexture.psd.meta" (Stores all importer settings)
• The internal version number of the texture importer
• A hash of version numbers of all AssetPostprocessors

If that hash is different from what is stored on the Cache Server, the asset will be reimported, otherwise the cached version will be downloaded. The client Unity editor will only pull assets from the server as they are needed - assets don't get pushed to each project as they change.

How do I work with Asset dependencies?

The Cache Server does not handle dependencies. Unity's asset pipeline does not deal with the concept of dependencies. It is built in such a way as to avoid dependencies between assets. AssetPostprocessors are a common technique used to customize the Asset importer to fit your needs. For example, you might want to add MeshColliders to some GameObjects in an fbx file based on their name or tag.

It is also easy to use AssetPostprocessors to introduce dependencies. For example you might use data from a text file next to the asset to add additional components to the imported game objects. This is not supported in the Cache Server. If you want to use the Cache Server, you will have to remove dependency on other assets in the project folder. Since the Cache Server doesn't know anything about the dependency in your postprocessor, it will not know that anything has changed thus use an old cached version of the asset.

In practice there are plenty of ways you can do asset postprocessing to work well with the cache server. You can use:

• The Path of the imported asset
• Any import settings of the asset
• The source asset itself or any data generated from it passed to you in the asset postprocessor.

Are there any issues when working with materials?

Modifying materials that already exist might cause trouble. When using the Cache Server, Unity validates that the references to materials are maintained. But since no postprocessing calls will be invoked, the contents of the material can not be changed when a model is imported through the Cache Server. Thus you might get different results when importing with or without Cache Server. It is best to never modify materials that already exist on disk.

Are there any asset types which will not be cached by the server?

There are a few kinds of asset data which the server doesn't cache. There isn't really anything to be gained by caching script files and so the server will ignore them. Also, native files used by 3D modelling software (Maya, 3D Max, etc) are converted to FBX using the application itself. Currently, the asset server caches neither the native file nor the intermediate FBX file generated in the import process. However, it is possible to benefit from the server by exporting files as FBX from the modelling software and adding those to the Unity project.

Behind the Scenes

Unity automatically imports assets and manages various kinds of additional data about them for you. Below is a description of how this process works.

When you place an Asset such as a texture in the Assets folder, Unity will first detect that a new file has been added (the editor frequently checks the contents of the Assets folder against the list of assets it already knows about). Once a unique ID value has been assigned to the asset to enable it to be accessed internally, it will be imported and processed. The asset that you actually see in the Project panel is the result of that processing and its data contents will typically be different to those of the original asset. For example, a texture may be present in the Assets folder as a PNG file but will be converted to an internal format after import and processing.

Using an internal format for assets allows Unity to keep additional data known as metadata which enables the asset data to be handled in a much more flexible way. For example, the Photoshop file format is convenient to work with, but you wouldn't expect it to support game engine features such as mip maps. Unity's internal format, however, can add extra functionality like this to any asset type. All metadata for assets is stored in the Library folder. As as user, you should never have to alter the Library folder manually and attempting to do so may corrupt the project.

Unity allows you to create folders in the Project view to help you organize assets, and those folders will be mirrored in the actual filesystem. However, you must move the files within Unity by dragging and dropping in the Project view. If you attempt to use the filesystem/desktop to move the files then Unity will misinterpret the change (it will appear that the old asset has been deleted and a new one created in its place). This will lose information, such as links between assets and scripts in the project.

When backing up a project, you should always back up the main Unity project folder, containing both the Assets and Library folders. All the information in the subfolders is crucial to the way Unity works.

Creating Gameplay

Unity は、ゲーム デザイナーにゲームを作成する力を与えます。 Unity の特別な点は、何年ものコード記述の経験や、面白いゲームを作るための美術の学位は不要という点です。 Unity を学ぶのに必要な基本的なワークフローのコンセプトはわずかです。 一旦理解すれば、すぐにゲーム作成に移ることができるでしょう。 ゲームの起動や実行にかかる時間w節約できるので、その分ゲームをより完璧に仕上げるために、改良やバランス調整、微調整などに時間を回すことができます。

本項では、独特で、驚くべき、楽しいゲームプレイを作成するために必要な主要コンセプトについて説明します。 このコンセプトの大半で、 Scripts を記述する必要があります。 スクリプトの作成および使用の概要については、Scripting ページを参照してください。

• Instantiating Prefabs at runtime
• Input
• Transforms
• Physics
• Adding Random Gameplay Elements
• Particle Systems
  • パーティクルシステムCurve Editor
  • パーティクルシステムの色およびグラデーション（Shuriken）
  • Gradient Editor
  • Particle System Inspector
  • Introduction to Particle System Modules (Shuriken)
  • Particle System Modules (Shuriken)
  • Particle Effects (Shuriken)
• Mecanim Animation System
  • A Glossary of Animation and Mecanim terms
  • Asset Preparation and Import
    • Preparing your own character
    • Importing Animations
    • Splitting Animations
  • Working with humanoid animations
    • Avatar作成
    • Configuring the Avatar
    • Muscle setup
    • Avatar Body Mask
    • Retargeting of Humanoid animations
    • Inverse Kinematics (Pro only)
  • Generic Animations in Mecanim
  • Bringing characters to life
    • Looping animation clips
    • Animator Component and Animator Controller
    • Animation State Machines
      • Animation States
      • Animation Transitions
      • Animation Parameters
    • Blend Trees
    • Mecanim Advanced topics:
      • Working with Animation Curves in Mecanim (Pro only)
      • Nested State Machines
      • Animation Layers
      • Animation State Machine Preview (solo and mute)
      • Target Matching
      • Root Motion - how it works
        • Manually Scripting Root Motion
• Animations (Legacy)
  • Animation View Guide (Legacy)
  • Animation Scripting (Legacy)
• Navmesh and Pathfinding (Pro only)
  • Navmesh Baking
• Sound
• Game Interface Elements
• Networked Multiplayer

Instantiating Prefabs

By this point you should understand the concept of Prefabs at a fundamental level. They are a collection of predefined GameObjects & Components that are re-usable throughout your game. If you don't know what a Prefab is, we recommend you read the Prefabs page for a more basic introduction.

Prefabs come in very handy when you want to instantiate complicated GameObjects at runtime. The alternative to instantiating Prefabs is to create GameObjects from scratch using code. Instantiating Prefabs has many advantages over the alternative approach:

• You can instantiate a Prefab from one line of code, with complete functionality. Creating equivalent GameObjects from code takes an average of five lines of code, but likely more.
• You can set up, test, and modify the Prefab quickly and easily in the Scene and Inspector.
• You can change the Prefab being instanced without changing the code that instantiates it. A simple rocket might be altered into a super-charged rocket, and no code changes are required.

Common Scenarios

To illustrate the strength of Prefabs, let's consider some basic situations where they would come in handy:

1. Building a wall out of a single "brick" Prefab by creating it several times in different positions.
2. A rocket launcher instantiates a flying rocket Prefab when fired. The Prefab contains a Mesh, Rigidbody, Collider, and a child GameObject with its own trail Particle System.
3. A robot exploding to many pieces. The complete, operational robot is destroyed and replaced with a wrecked robot Prefab. This Prefab would consist of the robot split into many parts, all set up with Rigidbodies and Particle Systems of their own. This technique allows you to blow up a robot into many pieces, with just one line of code, replacing one object with a Prefab.

Building a wall

This explanation will illustrate the advantages of using a Prefab vs creating objects from code.

First, lets build a brick wall from code:

// JavaScript
function Start () {
    for (var y = 0; y < 5; y++) {
        for (var x = 0; x < 5; x++) {
            var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
            cube.AddComponent(Rigidbody);
            cube.transform.position = Vector3 (x, y, 0);
        }
    }
}


// C#
public class Instantiation : MonoBehaviour {

	void Start() {
		for (int y = 0; y < 5; y++) {
			for (int x = 0; x < 5; x++) {
				GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
				cube.AddComponent<Rigidbody>();
				cube.transform.position = new Vector3(x, y, 0);
			}
		}
	}
}

• To use the above script we simply save the script and drag it onto an empty GameObject.
• Create an empty GameObject with GameObject->Create Empty.

If you execute that code, you will see an entire brick wall is created when you enter Play Mode. There are two lines relevant to the functionality of each individual brick: the CreatePrimitive() line, and the AddComponent() line. Not so bad right now, but each of our bricks is un-textured. Every additional action to want to perform on the brick, like changing the texture, the friction, or the Rigidbody mass, is an extra line.

If you create a Prefab and perform all your setup before-hand, you use one line of code to perform the creation and setup of each brick. This relieves you from maintaining and changing a lot of code when you decide you want to make changes. With a Prefab, you just make your changes and Play. No code alterations required.

If you're using a Prefab for each individual brick, this is the code you need to create the wall.

// JavaScript

var brick : Transform;
function Start () {
    for (var y = 0; y < 5; y++) {
        for (var x = 0; x < 5; x++) {
            Instantiate(brick, Vector3 (x, y, 0), Quaternion.identity);
        }
    }
}


// C#
public Transform brick;

void Start() {
	for (int y = 0; y < 5; y++) {
		for (int x = 0; x < 5; x++) {
			Instantiate(brick, new Vector3(x, y, 0), Quaternion.identity);
		}
	}
}

This is not only very clean but also very reusable. There is nothing saying we are instantiating a cube or that it must contain a rigidbody. All of this is defined in the Prefab and can be quickly created in the Editor.

Now we only need to create the Prefab, which we do in the Editor. Here's how:

1. Choose GameObject->Create Other->Cube
2. Choose Component->Physics->Rigidbody
3. Choose Assets->Create->Prefab
4. In the Project View, change the name of your new Prefab to "Brick"
5. Drag the cube you created in the Hierarchy onto the "Brick" Prefab in the Project View
6. With the Prefab created, you can safely delete the Cube from the Hierarchy (Delete on Windows, Command-Backspace on Mac)

We've created our Brick Prefab, so now we have to attach it to the brick variable in our script. Select the empty GameObject that contains the script. Notice that a new variable has appeared in the Inspector, called "brick".

This variable can accept any GameObject or Prefab

Now drag the "Brick" Prefab from the Project View onto the brick variable in the Inspector. Press Play and you'll see the wall built using the Prefab.

This is a workflow pattern that can be used over and over again in Unity. In the beginning you might wonder why this is so much better, because the script creating the cube from code is only 2 lines longer.

But because you are using a Prefab now, you can adjust the Prefab in seconds. Want to change the mass of all those instances? Adjust the Rigidbody in the Prefab only once. Want to use a different Material for all the instances? Drag the Material onto the Prefab only once. Want to change friction? Use a different Physic Material in the Prefab's collider. Want to add a Particle System to all those boxes? Add a child to the Prefab only once.

Instantiating rockets & explosions

Here's how Prefabs fit into this scenario:

1. A rocket launcher instantiates a rocket Prefab when the user presses fire. The Prefab contains a mesh, Rigidbody, Collider, and a child GameObject that contains a trail particle system.
2. The rocket impacts and instantiates an explosion Prefab. The explosion Prefab contains a Particle System, a light that fades out over time, and a script that applies damage to surrounding GameObjects.

While it would be possible to build a rocket GameObject completely from code, adding Components manually and setting properties, it is far easier to instantiate a Prefab. You can instantiate the rocket in just one line of code, no matter how complex the rocket's Prefab is. After instantiating the Prefab you can also modify any properties of the instantiated object (e.g. you can set the velocity of the rocket's Rigidbody).

Aside from being easier to use, you can update the prefab later on. So if you are building a rocket, you don't immediately have to add a Particle trail to it. You can do that later. As soon as you add the trail as a child GameObject to the Prefab, all your instantiated rockets will have particle trails. And lastly, you can quickly tweak the properties of the rocket Prefab in the Inspector, making it far easier to fine-tune your game.

This script shows how to launch a rocket using the Instantiate() function.

// JavaScript

// Require the rocket to be a rigidbody.
// This way we the user can not assign a prefab without rigidbody
var rocket : Rigidbody;
var speed = 10.0;

function FireRocket () {
    var rocketClone : Rigidbody = Instantiate(rocket, transform.position, transform.rotation);
    rocketClone.velocity = transform.forward * speed;
    // You can also acccess other components / scripts of the clone
    rocketClone.GetComponent(MyRocketScript).DoSomething();
}

// Calls the fire method when holding down ctrl or mouse
function Update () {
    if (Input.GetButtonDown("Fire1")) {
        FireRocket();
    }
}


// C#

// Require the rocket to be a rigidbody.
// This way we the user can not assign a prefab without rigidbody
public Rigidbody rocket;
public float speed = 10f;

void FireRocket () {
	Rigidbody rocketClone = (Rigidbody) Instantiate(rocket, transform.position, transform.rotation);
	rocketClone.velocity = transform.forward * speed;

	// You can also acccess other components / scripts of the clone
	rocketClone.GetComponent<MyRocketScript>().DoSomething();
}

// Calls the fire method when holding down ctrl or mouse
void Update () {
	if (Input.GetButtonDown("Fire1")) {
		FireRocket();
	}
}

Replacing a character with a ragdoll or wreck

Let's say you have a fully rigged enemy character and he dies. You could simply play a death animation on the character and disable all scripts that usually handle the enemy logic. You probably have to take care of removing several scripts, adding some custom logic to make sure that no one will continue attacking the dead enemy anymore, and other cleanup tasks.

A far better approach is to immediately delete the entire character and replace it with an instantiated wrecked prefab. This gives you a lot of flexibility. You could use a different material for the dead character, attach completely different scripts, spawn a Prefab containing the object broken into many pieces to simulate a shattered enemy, or simply instantiate a Prefab containing a version of the character.

Any of these options can be achieved with a single call to Instantiate(), you just have to hook it up to the right prefab and you're set!

The important part to remember is that the wreck which you Instantiate() can be made of completely different objects than the original. For example, if you have an airplane, you would model two versions. One where the plane consists of a single GameObject with Mesh Renderer and scripts for airplane physics. By keeping the model in just one GameObject, your game will run faster since you will be able to make the model with less triangles and since it consists of fewer objects it will render faster than using many small parts. Also while your plane is happily flying around there is no reason to have it in separate parts.

To build a wrecked airplane Prefab, the typical steps are:

1. Model your airplane with lots of different parts in your favorite modeler
2. Create an empty Scene
3. Drag the model into the empty Scene
4. Add Rigidbodies to all parts, by selecting all the parts and choosing Component->Physics->Rigidbody
5. Add Box Colliders to all parts by selecting all the parts and choosing Component->Physics->Box Collider
6. For an extra special effect, add a smoke-like Particle System as a child GameObject to each of the parts
7. Now you have an airplane with multiple exploded parts, they fall to the ground by physics and will create a Particle trail due to the attached particle system. Hit Play to preview how your model reacts and do any necessary tweaks.
8. Choose Assets->Create Prefab
9. Drag the root GameObject containing all the airplane parts into the Prefab

// JavaScript

var wreck : GameObject;

// As an example, we turn the game object into a wreck after 3 seconds automatically
function Start () {
    yield WaitForSeconds(3);
    KillSelf();
}

// Calls the fire method when holding down ctrl or mouse
function KillSelf () {
    // Instantiate the wreck game object at the same position we are at
    var wreckClone = Instantiate(wreck, transform.position, transform.rotation);

    // Sometimes we need to carry over some variables from this object
    // to the wreck
    wreckClone.GetComponent(MyScript).someVariable = GetComponent(MyScript).someVariable;

    // Kill ourselves
    Destroy(gameObject);


// C#

public GameObject wreck;

// As an example, we turn the game object into a wreck after 3 seconds automatically
IEnumerator Start() {
	yield return new WaitForSeconds(3);
	KillSelf();
}

// Calls the fire method when holding down ctrl or mouse
void KillSelf () {
	// Instantiate the wreck game object at the same position we are at
	GameObject wreckClone = (GameObject) Instantiate(wreck, transform.position, transform.rotation);

	// Sometimes we need to carry over some variables from this object
	// to the wreck
	wreckClone.GetComponent<MyScript>().someVariable = GetComponent<MyScript>().someVariable;

	// Kill ourselves
	Destroy(gameObject);
}

} 

The First Person Shooter tutorial explains how to replace a character with a ragdoll version and also synchronize limbs with the last state of the animation. You can find that tutorial on the Tutorials page.

Placing a bunch of objects in a specific pattern

Lets say you want to place a bunch of objects in a grid or circle pattern. Traditionally this would be done by either:

1. Building an object completely from code. This is tedious! Entering values from a script is both slow, unintuitive and not worth the hassle.
2. Make the fully rigged object, duplicate it and place it multiple times in the scene. This is tedious, and placing objects accurately in a grid is hard.

So use Instantiate() with a Prefab instead! We think you get the idea of why Prefabs are so useful in these scenarios. Here's the code necessary for these scenarios:

// JavaScript

// Instantiates a prefab in a circle

var prefab : GameObject;
var numberOfObjects = 20;
var radius = 5;

function Start () {
    for (var i = 0; i < numberOfObjects; i++) {
        var angle = i * Mathf.PI * 2 / numberOfObjects;
        var pos = Vector3 (Mathf.Cos(angle), 0, Mathf.Sin(angle)) * radius;
        Instantiate(prefab, pos, Quaternion.identity);
    }
}


// C#
// Instantiates a prefab in a circle

public GameObject prefab;
public int numberOfObjects = 20;
public float radius = 5f;

void Start() {
	for (int i = 0; i < numberOfObjects; i++) {
		float angle = i * Mathf.PI * 2 / numberOfObjects;
		Vector3 pos = new Vector3(Mathf.Cos(angle), 0, Mathf.Sin(angle)) * radius;
		Instantiate(prefab, pos, Quaternion.identity);
	}
}

// JavaScript

// Instantiates a prefab in a grid

var prefab : GameObject;
var gridX = 5;
var gridY = 5;
var spacing = 2.0;

function Start () {
    for (var y = 0; y < gridY; y++) {
        for (var x=0;x<gridX;x++) {
            var pos = Vector3 (x, 0, y) * spacing;
            Instantiate(prefab, pos, Quaternion.identity);
        }
    }
}


// C#

// Instantiates a prefab in a grid

public GameObject prefab;
public float gridX = 5f;
public float gridY = 5f;
public float spacing = 2f;

void Start() {
	for (int y = 0; y < gridY; y++) {
		for (int x = 0; x < gridX; x++) {
			Vector3 pos = new Vector3(x, 0, y) * spacing;
			Instantiate(prefab, pos, Quaternion.identity);
		}
	}
} 

Input

Desktop

Note: Keyboard, joystick and gamepad input work on the desktop versions of Unity (including webplayer and Flash) but not on mobiles.

Unity supports keyboard, joystick and gamepad input.

Virtual axes and buttons can be created in the Input Manager, and end users can configure Keyboard input in a nice screen configuration dialog.

You can setup joysticks, gamepads, keyboard, and mouse, then access them all through one simple scripting interface.

From scripts, all virtual axes are accessed by their name.

Every project has the following default input axes when it's created:

• Horizontal and Vertical are mapped to w, a, s, d and the arrow keys.
• Fire1, Fire2, Fire3 are mapped to Control, Option (Alt), and Command, respectively.
• Mouse X and Mouse Y are mapped to the delta of mouse movement.
• Window Shake X and Window Shake Y is mapped to the movement of the window.

Adding new Input Axes

If you want to add new virtual axes go to the Edit->Project Settings->Input menu. Here you can also change the settings of each axis.

You map each axis to two buttons on a joystick, mouse, or keyboard keys.

Name	The name of the string used to check this axis from a script.
Descriptive Name	Positive value name displayed in the input tab of the Configuration dialog for standalone builds.
Descriptive Negative Name	Negative value name displayed in the Input tab of the Configuration dialog for standalone builds.
Negative Button	The button used to push the axis in the negative direction.
Positive Button	The button used to push the axis in the positive direction.
Alt Negative Button	Alternative button used to push the axis in the negative direction.
Alt Positive Button	Alternative button used to push the axis in the positive direction.
Gravity	Speed in units per second that the axis falls toward neutral when no buttons are pressed.
Dead	Size of the analog dead zone. All analog device values within this range result map to neutral.
Sensitivity	Speed in units per second that the the axis will move toward the target value. This is for digital devices only.
Snap	If enabled, the axis value will reset to zero when pressing a button of the opposite direction.
Invert	If enabled, the Negative Buttons provide a positive value, and vice-versa.
Type	The type of inputs that will control this axis.
Axis	The axis of a connected device that will control this axis.
Joy Num	The connected Joystick that will control this axis.

Use these settings to fine tune the look and feel of input. They are all documented with tooltips in the Editor as well.

Using Input Axes from Scripts

You can query the current state from a script like this:

value = Input.GetAxis ("Horizontal");

An axis has a value between -1 and 1. The neutral position is 0. This is the case for joystick input and keyboard input.

However, Mouse Delta and Window Shake Delta are how much the mouse or window moved during the last frame. This means it can be larger than 1 or smaller than -1 when the user moves the mouse quickly.

It is possible to create multiple axes with the same name. When getting the input axis, the axis with the largest absolute value will be returned. This makes it possible to assign more than one input device to one axis name. For example, create one axis for keyboard input and one axis for joystick input with the same name. If the user is using the joystick, input will come from the joystick, otherwise input will come from the keyboard. This way you don't have to consider where the input comes from when writing scripts.

Button Names

To map a key to an axis, you have to enter the key's name in the Positive Button or Negative Button property in the Inspector.

The names of keys follow this convention:

• Normal keys: "a", "b", "c" ...
• Number keys: "1", "2", "3", ...
• Arrow keys: "up", "down", "left", "right"
• Keypad keys: "[1]", "[2]", "[3]", "[+]", "[equals]"
• Modifier keys: "right shift", "left shift", "right ctrl", "left ctrl", "right alt", "left alt", "right cmd", "left cmd"
• Mouse Buttons: "mouse 0", "mouse 1", "mouse 2", ...
• Joystick Buttons (from any joystick): "joystick button 0", "joystick button 1", "joystick button 2", ...
• Joystick Buttons (from a specific joystick): "joystick 1 button 0", "joystick 1 button 1", "joystick 2 button 0", ...
• Special keys: "backspace", "tab", "return", "escape", "space", "delete", "enter", "insert", "home", "end", "page up", "page down"
• Function keys: "f1", "f2", "f3", ...

The names used to identify the keys are the same in the scripting interface and the Inspector.

value = Input.GetKey ("a");

Mobile Input

On iOS and Android, the Input class offers access to touchscreen, accelerometer and geographical/location input.

Access to keyboard on mobile devices is provided via the iOS keyboard.

Multi-Touch Screen

The iPhone and iPod Touch devices are capable of tracking up to five fingers touching the screen simultaneously. You can retrieve the status of each finger touching the screen during the last frame by accessing the Input.touches property array.

Each finger touch is represented by an Input.Touch data structure:

Phase can be one of the following:

Following is an example script which will shoot a ray whenever the user taps on the screen:

var particle : GameObject;
function Update () {
	for (var touch : Touch in Input.touches) {
		if (touch.phase == TouchPhase.Began) {
			// Construct a ray from the current touch coordinates
			var ray = Camera.main.ScreenPointToRay (touch.position);
			if (Physics.Raycast (ray)) {
				// Create a particle if hit
				Instantiate (particle, transform.position, transform.rotation);
			}
		}
	}
}

Mouse Simulation

On top of native touch support Unity iOS/Android provides a mouse simulation. You can use mouse functionality from the standard Input class.

Device Orientation

Unity iOS/Android allows you to get discrete description of the device physical orientation in three-dimensional space. Detecting a change in orientation can be useful if you want to create game behaviors depending on how the user is holding the device.

You can retrieve device orientation by accessing the Input.deviceOrientation property. Orientation can be one of the following:

Accelerometer

As the mobile device moves, a built-in accelerometer reports linear acceleration changes along the three primary axes in three-dimensional space. Acceleration along each axis is reported directly by the hardware as G-force values. A value of 1.0 represents a load of about +1g along a given axis while a value of -1.0 represents -1g. If you hold the device upright (with the home button at the bottom) in front of you, the X axis is positive along the right, the Y axis is positive directly up, and the Z axis is positive pointing toward you.

You can retrieve the accelerometer value by accessing the Input.acceleration property.

The following is an example script which will move an object using the accelerometer:

var speed = 10.0;
function Update () {
	var dir : Vector3 = Vector3.zero;

	// we assume that the device is held parallel to the ground
	// and the Home button is in the right hand

	// remap the device acceleration axis to game coordinates:
	//  1) XY plane of the device is mapped onto XZ plane
	//  2) rotated 90 degrees around Y axis
	dir.x = -Input.acceleration.y;
	dir.z = Input.acceleration.x;

	// clamp acceleration vector to the unit sphere
	if (dir.sqrMagnitude > 1)
		dir.Normalize();

	// Make it move 10 meters per second instead of 10 meters per frame...
	dir *= Time.deltaTime;

	// Move object
	transform.Translate (dir * speed);
}

Low-Pass Filter

Accelerometer readings can be jerky and noisy. Applying low-pass filtering on the signal allows you to smooth it and get rid of high frequency noise.

The following script shows you how to apply low-pass filtering to accelerometer readings:

var AccelerometerUpdateInterval : float = 1.0 / 60.0;
var LowPassKernelWidthInSeconds : float = 1.0;

private var LowPassFilterFactor : float = AccelerometerUpdateInterval / LowPassKernelWidthInSeconds; // tweakable
private var lowPassValue : Vector3 = Vector3.zero;
function Start () {
	lowPassValue = Input.acceleration;
}

function LowPassFilterAccelerometer() : Vector3 {
	lowPassValue = Mathf.Lerp(lowPassValue, Input.acceleration, LowPassFilterFactor);
	return lowPassValue;
}

The greater the value of LowPassKernelWidthInSeconds, the slower the filtered value will converge towards the current input sample (and vice versa). You should be able to use the LowPassFilter() function instead of avgSamples().

I'd like as much precision as possible when reading the accelerometer. What should I do?

Reading the Input.acceleration variable does not equal sampling the hardware. Put simply, Unity samples the hardware at a frequency of 60Hz and stores the result into the variable. In reality, things are a little bit more complicated -- accelerometer sampling doesn't occur at consistent time intervals, if under significant CPU loads. As a result, the system might report 2 samples during one frame, then 1 sample during the next frame.

You can access all measurements executed by accelerometer during the frame. The following code will illustrate a simple average of all the accelerometer events that were collected within the last frame:

var period : float = 0.0;
var acc : Vector3 = Vector3.zero;
for (var evnt : iPhoneAccelerationEvent  in iPhoneInput.accelerationEvents) {
	acc += evnt.acceleration * evnt.deltaTime;
	period += evnt.deltaTime;
}
if (period > 0)
	acc *= 1.0/period;
return acc;

Further Reading

The Unity mobile input API is originally based on Apple's API. It may help to learn more about the native API to better understand Unity's Input API. You can find the Apple input API documentation here:

• Programming Guide: Event Handling (Apple iPhone SDK documentation)
• UITouch Class Reference (Apple iOS SDK documentation)

Note: The above links reference your locally installed iPhone SDK Reference Documentation and will contain native ObjectiveC code. It is not necessary to understand these documents for using Unity on mobile devices, but may be helpful to some!

iOS

Transforms

Transforms are a key Component in every GameObject. They dictate where the GameObject is positioned, how it is rotated, and its scale. It is impossible to have a GameObject without a Transform. You can adjust the Transform of any GameObject from the Scene View, the Inspector, or through Scripting.

The remainder of this page's text is from the Transform Component Reference page.

トランスフォーム

Transform Componentは、シーン内のすべてのオブジェクトの実際の「Position」、「Rotation」および「Scale」を決定します。 オブジェクトはそれぞれトランスフォームを持ちます。

「Inspector 表示・編集可能なトランスフォーム コンポーネント」

プロパティ

トランスフォームのプロパティはすべて、トランスフォームの親に対して相対的に設定されます（詳細は以下で参照下さい）。 トランスフォームに親がない場合、プロパティはワールド空間にもとづき設定されます。

トランスフォームの使用

トランスフォームは、X、Y、Z軸を使用して、3D 空間で操作されます。Unity では、これらの軸は、それぞれ赤色、緑色、青色で表示されます。 XYZ = RGBと覚えてださい。

「3 つの軸間の色記号とトランスフォーム プロパティの関係」

トランスフォーム コンポーネントは、Scene View またはインスペクタタ上のプロパティを編集して、直接操作できます。シーンでは、Move、Rotate およびScale ツールを使用して、トランスフォームを操作できます。 これらのツールは、Unity エディタの左上にあります。

「View、Translat、Rotate および Scale ツール」

これらのツールは、シーン内のどのオブジェクトにも使用できます。 オブジェクトをクリックすると、そこにツールのギズモが表示されます。 現在どのツールを選択しているかにより、このギズモの表示が若干異なります。

3 つのギズモはすべてシーン ビューで直接編集できます。

トランスフォームを操作するには、3 つのギズモの軸のいずれかをクリックして、ドラッグすると、色が変わります。 マウスをドラッグするのに合わせ、オブジェクトが軸に沿って、移動、回転または縮小拡大します。 マウス ボタンを放すと、軸が選択されたままになります。 マウスの中ボタンをクリックし、マウスをドラッグして、選択した軸に沿って、トランスフォームを操作できます。

「個々の軸をクリックすると、選択されます」

親子関係

親子関係は、Unity を使用する際に理解する必要のある最も重要なコンセプトのひとつです。 GameObject が別の GameObject の Parent（親）の場合、Child（子）GameObject は、親とまったく同じように移動、回転、縮小拡大します。 体に付いている腕のように、体を回転させると、体に付いているため、腕も動きます。 どのオブジェクトにも複数の子がありますが、親は 1 つだけです。

Hierarchy View 内の GameObject を別の GameObject にドラッグすることで、親を作成できます。 これにより、2 つの GameObject 間で親子関係が作成されます。

「親子階層の例。 左の矢印で示されるすべての GameObject は親です。」

上記の例では、体が腕の親になっており、腕は手の親になっています。 Unity で作成したシーンには、これらの Transform hierarchy の集合が含まれます。 一番上の親オブジェクトは、Root object と呼ばれます。 親を移動、縮小拡大または回転させると、そのトランスフォームでの変更はすべてその子にも適用されます。

子 GameObject のインスペクタでのトランスフォームの値は、親のトランスフォームの値に対し相対的に表示されるということはポイントです。これらは Local Coordinate（ローカル座標）と呼ばれます。 スクリプティングを通じて、ローカル座標の他、 Global Coordinate（グローバル座標）にもアクセスできます。

いくつかの別々のオブジェクトに親子関係を持たせることにより、人体模型の骸骨の構造のように、複合的なオブジェクトを作成できます。 また、シンプルな構造でも便利な効果得られます。例えば、舞台設定が夜中であるホラー ゲームで、懐中電灯を活用した場面を作りたいとします。このオブジェクトを作成するには、spotlightトランスフォームを懐中電灯トランスフォームの親にします。 これで、懐中電灯トランスフォームに変更を加えると、spotlightも変更され、リアルな懐中電灯の効果を生み出すことができます。

不均等なScaleによるパフォーマンス問題や制限

不均等なScaleとは、トランスフォームにおけるScaleがx、y、z方向で異なる値があるケースです（例：(2, 4, 2)）。対比となるのが均等であるScaleで、x、y、z方向で同じ値があるケースです（例：(3, 3, 3)）。均等でないScaleは限定されたケースでは便利かもしれませんが、通常は出来るかぎり避けるべきです。

不均等なScaleはレンダリングのパフォーマンスにマイナスのインパクトがあります。頂点法線を正しく変換するため、CPU上でメッシュを変換しデータの複製をします。通常はインスタンス間で共有されるメッシュはグラフィックスメモリに保持しますが、このケースではCPUとメモリ双方のコストがインスタンスごとに発生します。

Unityが不均等なScaleを扱う場合、特定の制限事項もあります。

• 特定のコンポーネントは不均等なScaleを完全にサポートしていません。例えば、radiusプロパティがある場合、あるいは似たケースでSphere Collider、Capsule Collider、 Light、Audio Source、等で不均等なScaleにしていたとしても形状は楕円にならず、円状/球状となります。
• 子オブジェクトが不均等なScaleの親を持ち、親に対して相対的に回転した場合、それは非直交配列になり、すなわち歪んで表示されることがあります。不均等なScaleをサポートするコンポーネントについても、非直行配列はサポートしていません。例えば、 Box Colliderを歪ませることはできないため、不均等なScaleとした場合Box Colliderはレンダリングされたメッシュと正確にマッチしなくなります。
• パフォーマンスによる理由で、子オブジェクトがが不均等なScaleの親を持った場合、Scale/Matrixが回転時に自動反映されなくなります。Scaleの更新によっては、はじけるような動作となり、たとえばオブジェクトを親から切り離した場合に発生します。

スケールの重要性

トランスフォームのスケールは、モデリング アプリケーションのメッシュのサイズと、Unity でのメッシュのサイズ間の差分を決定します。 Unity でのメッシュのサイズ (およびトランスフォームのスケール)は、特に物理挙動のシミュレーション中には非常に重要になります。次の3つの要因によって、オブジェクトのスケールが決まります。

• 3D モデリング アプリケーションでのメッシュのサイズ。
• オブジェクトの Import Settings での「Mesh Scale Factor」設定。
• トランスフォーム コンポーネントの「Scale」値。

理想的には、トランスフォームコンポーネントでのオブジェクトの「スケール」を調整する必要はありません。 実際のスケールでモデルを作成するため、トランスフォームのスケールを変更する必要がないというのが最高の選択肢です。 個々のメッシュに対して、Import Settings にメッシュをインポートしたスケールを調整するのが、次に良い選択肢になります。インポート サイズに基づいて、一定の最適化が行われ、調整されたスケール値を持つオブジェクトをインスタンス化すると、パフォーマンスが下がる場合があります。詳細については、Rigidbody コンポーネントのスケールの最適化に関する項目を参照してください。

ヒント

• トランスフォームのパレンディングを行う際、子を適用する前に、親の位置を <0,0,0> に置きます。 これにより、後で悩むケースを多々、未然防止できます。
• Particle System は、トランスフォームの「Scale」の影響は受けません。 パーティクルシステムの縮小拡大を行うには、システムのパーティクルエミッタ、アニメータ、およびレンダラのプロパティを修正する必要があります。
• 物理挙動のシミュレーションに Rigidbodｙ を使用する場合は、Rigidbody ページに記載されている Scale プロパティに関する重要な情報を参照してください。
• Unity Menu->Preferences->Colors & keys から、トランスフォームの軸の色 (およびその他の UI 要素)を変更できます。
• Unityでのスケーリングを回避出来る場合は、そうしてください。 オブジェクトのスケールを 3D モデリング アプリケーション、またはメッシュの Import Settings で完結するようにして下さい。

Physics

Unity has NVIDIA PhysX physics engine built-in. This allows for unique emergent behaviour and has many useful features.

Basics

To put an object under physics control, simply add a Rigidbody to it. When you do this, the object will be affected by gravity, and can collide with other objects in the world.

Rigidbodies

Rigidbodies are physically simulated objects. You use Rigidbodies for things that the player can push around, for example crates or loose objects, or you can move Rigidbodies around directly by adding forces to it by scripting.

If you move the Transform of a non-Kinematic Rigidbody directly it may not collide correctly with other objects. Instead you should move a Rigidbody by applying forces and torque to it. You can also add Joints to rigidbodies to make the behavior more complex. For example, you could make a physical door or a crane with a swinging chain.

You also use Rigidbodies to bring vehicles to life, for example you can make cars using a Rigidbody, 4 Wheel Colliders and a script applying wheel forces based on the user's Input.

You can make airplanes by applying forces to the Rigidbody from a script. Or you can create special vehicles or robots by adding various Joints and applying forces via scripting.

Rigidbodies are most often used in combination with primitive colliders.

Tips:

• You should never have a parent and child rigidbody together
• You should never scale the parent of a rigidbody

Kinematic Rigidbodies

A Kinematic Rigidbody is a Rigidbody that has the isKinematic option enabled. Kinematic Rigidbodies are not affected by forces, gravity or collisions. They are driven explicitly by setting the position and rotation of the Transform or animating them, yet they can interact with other non-Kinematic Rigidbodies.

Kinematic Rigidbodies correctly wake up other Rigidbodies when they collide with them, and they apply friction to Rigidbodies placed on top of them.

These are a few example uses for Kinematic Rigidbodies:

1. Sometimes you want an object to be under physics control but in another situation to be controlled explicitly from a script or animation. For example you could make an animated character whose bones have Rigidbodies attached that are connected with joints for use as a Ragdoll. Most of the time the character is under animation control, thus you make the Rigidbody Kinematic. But when he gets hit you want him to turn into a Ragdoll and be affected by physics. To accomplish this, you simply disable the isKinematic property.
2. Sometimes you want a moving object that can push other objects yet not be pushed itself. For example if you have an animated platform and you want to place some Rigidbody boxes on top, you should make the platform a Kinematic Rigidbody instead of just a Collider without a Rigidbody.
3. You might want to have a Kinematic Rigidbody that is animated and have a real Rigidbody follow it using one of the available Joints.

Static Colliders

A Static Collider is a GameObject that has a Collider but not a Rigidbody. Static Colliders are used for level geometry which always stays at the same place and never moves around. You can add a Mesh Collider to your already existing graphical meshes (even better use the Import Settings Generate Colliders check box), or you can use one of the other Collider types.

You should never move a Static Collider on a frame by frame basis. Moving Static Colliders will cause an internal recomputation in PhysX that is quite expensive and which will result in a big drop in performance. On top of that the behaviour of waking up other Rigidbodies based on a Static Collider is undefined, and moving Static Colliders will not apply friction to Rigidbodies that touch it. Instead, Colliders that move should always be Kinematic Rigidbodies.

Character Controllers

You use Character Controllers if you want to make a humanoid character. This could be the main character in a third person platformer, FPS shooter or any enemy characters.

These Controllers don't follow the rules of physics since it will not feel right (in Doom you run 90 miles per hour, come to halt in one frame and turn on a dime). Instead, a Character Controller performs collision detection to make sure your characters can slide along walls, walk up and down stairs, etc.

Character Controllers are not affected by forces but they can push Rigidbodies by applying forces to them from a script. Usually, all humanoid characters are implemented using Character Controllers.

Character Controllers are inherently unphysical, thus if you want to apply real physics - Swing on ropes, get pushed by big rocks - to your character you have to use a Rigidbody, this will let you use joints and forces on your character. Character Controllers are always aligned along the Y axis, so you also need to use a Rigidbody if your character needs to be able to change orientation in space (for example under a changing gravity). However, be aware that tuning a Rigidbody to feel right for a character is hard due to the unphysical way in which game characters are expected to behave. Another difference is that Character Controllers can slide smoothly over steps of a specified height, while Rigidbodies will not.

If you parent a Character Controller with a Rigidbody you will get a "Joint" like behavior.

リジッドボディ

Rigidbody により、 GameObject が物理特性の制御下で動作するようになります。 リジッドボディは、力やトルクを受け、現実的な方向にオブジェクトを動かすことができます。 GameObject は、重力の影響を影響を受けるリジッドボディを含めるか、スクリプティングを通じて加えた力の下で動作するか、NVIDIA PhysX 物理特性エンジンを通じて、その他のオブジェクトと相互作用する必要があります。

「リジッドボディにより、GameObject は物理的影響の下で動作できます」

プロパティ

詳細

Rigidbody により、GameObject が物理特性エンジンの制御下で動作するようになります。 これにより、現実的な衝突、多様な種類のジョイント、その他のクールな動作へのゲートウェイが開きます。 リジッドボディに力を加えることで、GameObject を操作することによって、 Component を直接調整した場合とは違うルック & フィールを作成します。 一般に、リジッドボディと同じ GameObject のトランスフォームのどちらか一方だけを操作しないでください。

トランスフォームの操作とリジッドボディ間の最大の差は、力を使用するかしないかです。 リジッドボディは、力やトルクを受けることができますが、トランスフォームはできません。 トランスフォームは移動や回転はできますが、物理特性の使用とは異なります。 自分で試した場合は、その顕著な差に気づくでしょう。 リジッドボディに力/トルクを加えると、実際にオブジェクトの位置やトランスフォーム コンポーネントの回転を変更します。 このため、どちら一方だけを使用する必要があります。 物理特性使用中にトランスフォームを変更すると、衝突やその他の計算に問題が生じる場合があります。

リジッドボディは、物理特性エンジンに影響を受ける前に、GameObject に明示的に追加する必要があります。 メニューバーで「Components->Physics->Rigidbody」から選択したオブジェクトにリジッドボディを追加できます。 オブジェクトで物理特性の準備ができました。重力下に置かれ、スクリプティングを介して、力を受けることができますが、 Collider またはジョイントを追加して、正確に希望通りに動作させる必要があります。

親子関係

オブジェクトが物理特性の制御下にある場合、トランスフォームの親が移動する方法から半分独立して移動します。 親を移動すると、リジッドボディの子をそれに沿って引っ張ります。 しかし、リジッドボディは重力および衝突イベントへの対応により、落下していきます。

スクリプティング

リジッドボディをコントロールするため、最初にスクリプトを使用して、力またはトルクを追加します。 「AddForce()��� と「AddTorque() 」をオブジェクトのリジッドボディで呼び出すことでこれを行います。 物理特性を使用する際は、オブジェクトのトランスフォームを直接買えないようにしてください。

アニメーション

一部の状況で、主にラグドール効果を作成する場合に、アニメーションと物理特性間でオブジェクトのコントロールを切り替える必要があります。 このため、リジッドボディには、「isKinematic 」と付けることができます。 リジッドボディに「isKinematic」と付いている場合、衝突や力、physX のその他の部分の影響を受けません。 This means that you will have to control the object by manipulating the Transform コンポーネントを直接操作することで、オブジェクトをコントロールする必要があるということです。 キネマティック リジッドボディはその他のオブジェクトに影響しますが、これら自体は物理特性の影響を受けません。 例えば、キネマティック オブジェクトに追加されるジョイントは、そこに追加されたその他のリジッドボディを制約し、キネマティック リジッドボディは衝突を通じて、その他のリジッドボディに影響します。

コライダ

コライダは、衝突を発生させるために、リジッドボディと共に追加する必要のある別の種類のコンポーネントです。 2 つのリジッドボディが互いに衝突する場合、物理特性エンジンは、両方のオブジェクトもコライダを追加するまで、衝突を計算しません。 コライダのないリジッドボディは、物理特性シミュレーション中に互いを簡単に通過します。

「コライダはリジッドボディの物理特性の境界を定義します」

「Component->Physics」メニューでコライダを追加します。 詳細については、個々のコライダのコンポーネント リファレンス ページを参照してください。

• Box Collider - キューブのプリミティブの形状
• Sphere Collider - 球体のプリミティブの形状
• Capsule Collider - カプセルのプリミティブの形状
• Mesh Collider - オブジェクトのメッシュからコライダを作成し、別のメッシュ コライダとは衝突できません
• Wheel Collider - 車両またはその他の移動する乗り物の作成用

複合コライダ

複合コライダはプリミティブなコライダの組み合わせによりひとつのコライダとしての挙動を示すものです。便利な場面としては複雑なメッシュをコライダでしようしたいが、Mesh Colliderを使用できないケースです。複合コライダを作成する際はコライダオブジェクトの子オブジェクトを作成し、それから各々の子オブジェクトにプリミティブなコライダを追加します。これにより各々のコライダを別々に容易に配置、回転、拡大縮小することが出来ます。

リアルリティのある複合コライダ

上記の図では、ガンモデルのゲームオブジェクトはリジッドボディがアタッチされてあり、子オブジェクトして複数のプリミティブなコライダを含みます。親のリジッドボディが力により動かされた場合、子コライダが追従して動きます。プリミティブなコライダは環境上にあるMesh Colliderと衝突し、親リジッドボディは自身に加えられた力の作用、子コライダがシーン上他のコライダとの衝突した作用、の双方を加味して軌道が変化します。

Mesh Collider同士は通常では衝突しませんが、Convexをオンにした場合のみ衝突することが出来ます。良くある方法として、動く全てのオブジェクトにはプリミティブなコライダを組み合わせ、動かない背景のオブジェクトにMesh Colliderを使います。

連続衝突検出

連続衝突検出は、高速移動するコライダが互いに通過しないようにする機能です。 これは、通常の(「Discrete」) 衝突検出使用時、オブジェクトが 1 つのフレームでコライダの片側にあり、次のフレームでコライダを通過している場合に発生することがあります。 これを解決するには、高速移動するオブジェクトのリジッドボディで連続衝突検出を有効にできます。 衝突検出モードを「Continuous」に切り替え、リジッドボディがスタティックな (つまり、非リジッドボディ) MeshColliders を通過させないようにします。 衝突検出モードを「Continuous Dynamic」に切り替え、リジッドボディが、衝突検出モードを「Continuous」または「Continuous Dynamic」に設定したその他のサポートされているリジッドボディを通過させないようにします。 連続衝突検出は、Box-、Sphere- および CapsuleCollider でサポートされています。

正しいサイズの使用

GameObject のメッシュのサイズは、リジッドボディの質量よりもはるかに重要です。 リジッドボディが期待通りに動作しなていない場合、ゆっくり移動するか、浮くか、正しく衝突しません。 Unity のデフォルトの単位スケールは、1 単位 = 1 メートルなので、インポートされたメッシュのスケールは維持され、物理特性計算に適用されます。 例えば、倒壊しかけている高層ビルは、積み木で作った塔とはかなり違う形で崩れるため、正確にスケールするには、サイズの異なるオブジェクトをモデル化する必要があります。

人間をモデリングしている場合、Unity では、その人間の身長は約 2メートルになります。 オブジェクトが正しいサイズかどうかを確認するには、デフォルトのキューブと比較します。 GameObject->Create Other->Cube を使用して、キューブを新規作成します。 キューブの高さは、ちょうど 1 メートルになるため、作成している人間は 2 倍の慎重になります。

メッシュ自体を調整できない場合、Project View で選択し、メニューバーから Assets->Import Settings... を選択することで、特定のメッシュ　アセットの均一なスケールを変更できます。 ここでは、スケールを変更し、メッシュを再インポートできます。

ゲームで、GameObject を異なるスケールでインスタンス化する必要がある場合、トランスフォームのスケール軸の値を調整しても大丈夫です。 欠点は、物理特性シミュレーションは、オブジェクトのインスタンス化時に更に多くの作業を剃る必要があり、ゲーム内でパフォーマンスの低下を引き起こす可能性があります。 これは大きな損失ではありませんが、他の 2 つのオプションでスケールを仕上げることほど効率的ではありません。 不均一なスケールだと、パレンディング使用時に望まぬ動作を生じる場合があります。 このため、モデリング アプリケーションで正しいスケールでオブジェクトを作成するのが常に最適です。

ヒント

• 2 つのリジッドボディの相対的な「Mass」は、リジッドボディが互いに衝突する際に、どのように反応するかを決定します。
• 1 つのリジッドボディの「Mass」を他方より大きくしても、自由落下での落下速度は上がりません。 これを行うには、「Drag」を使用します。
• 「Drag」値が低いと、オブジェクトが重く見えるようになります。 この値が高いと、軽く見えます。 「Drag」の通常の値は、.001 (金属の塊) と 10 (羽) の間です。
• オブジェクトのトランスフォーム コンポーネントを直接操作しているが、物理特性が必要な場合、リジッドボディを追加し、キネマティックにします。
• トランスフォーム コンポーネントを通じて、GameObject を移動させているが、衝突/トリガー メッセージを受信したい場合は、リジッドボディを移動しているオブジェクトに追加する必要があります。

一定力

Constant Force は、Rigidbody に一定力を素早く加えるためのユーティリティです。 これは、高い速度で始めたくないが、代わりに加速していく場合に、ロケットのような 1 回限りのオブジェクトに最適です。

一定の力で前進するロケット

プロパティ

詳細

加速しながら前進するロケットを作成するには、Relative Forceを正の Z 軸に沿って設定します。 次に、剛体のDragプロパティを使用して、一定の最大速度を超えないようにします （ドラッグが高くなるほど、最大速度が下がります）。 剛体で、ロケットが常に軌道上にあるよう、重力をオフにします。

ヒント

• オブジェクトを上に流すには、正の Y 値のあるForceプロパティを持つ一定力を追加します。
• オブジェクトを上に飛ばすには、正の Z 値のあるRelative Forceプロパティを持つ一定力を追加します。

球体コライダ

Sphere Collider は、基本的な球体形状の衝突プリミティブです。

球体コライダの積み重ね

プロパティ

詳細

球体コライダは、均一なスケールにサイズ変更できますが、個々の軸に沿ってサイズ変更はされません。 落下する医師や、卓球の球、ビー玉などに最適です。

標準の球体コライダ

コライダはリジッドボディ（剛体）と連動してUnity上での物理挙動を実現します。リジッドボディというのは「オブジェクトを物理法則にしたがって動かす」一方で、コライダはオブジェクトが互いに衝突することを可能に｣します。コライダはリッジトボディとは別にオブジェクトにアタッチする必要があります。コライダとリジットボディは両方アタッチされなくとも良いですが、コリジョンの結果オブジェクトを動かすためにはリジッドボディがアタッチされていることは必須です。

二つのコライダ間で衝突が発生し、かつ少なくとも一つのオブジェクトにリジッドボディがアタッチされている場合、 3種類の 衝突 メッセージが 発行されます。これらのイベントはスクリプト作成時にハンドリングすることが出来ますし、独自のビヘイビアを定義することが出来るようになるとともにビルトインのNVIDIA PhysXエンジンを使用するかしないか自由に決めることができます。

トリガー

コライダをトリガーとしてマーキングする別の方法としてインスペクタでIsTrigger属性をチェックボックスにてオンするという方法があります。これによりトリガーは物理エンジンから無視されるようになり、コライダの衝突が発生した場合3種類の トリガー メッセージが 発行されます。トリガーはゲームにおける別イベントを発動するに際して便利です（カットシーンやドアの自動開閉、チュートリアルメッセージの表示、等々。想像を働かせれば様々なパターンで応用できます）

留意しないといけないこととして、二つのトリガーがトリガーイベント衝突時にを発行するためには、片方のトリガーはリジッドボディを含む必要があります。同様にトリガーが通常のコライダと衝突するためには片方のトリガーがリジッドボディを含む必要があります。全てのコライダ種類の一覧についていは図表にまとめてありますので、本項の「応用」セクションの「衝突アクションマトリクス」を参照下さい。

摩擦係数と反射係数

摩擦係数（friction）、反射係数（bouncyness）、やわらかさ（softness）は 物理マテリアル の属性として定義されています。スタンダードアセット のなかに頻繁に使用される物理マテリアルが含まれています。使用する際はPhysic Materialドロップダウンボックスをクリックし、どれかを選択します（例 Ice）。物理マテリアル については自分でカスタムのものを作成することができ、摩擦係数などすべて調整することが出来ます。

合成物コライダ

複合コライダはプリミティブなコライダの組み合わせによりひとつのコライダとしての挙動を示すものです。便利な場面としては複雑なメッシュをコライダでしようしたいが、Mesh Colliderを使用できないケースです。複合コライダを作成する際はコライダオブジェクトの子オブジェクトを作成し、それから各々の子オブジェクトにプリミティブなコライダを追加します。これにより各々のコライダを別々に容易に配置、回転、拡大縮小することが出来ます。

リアルリティのある複合コライダ

上記の図では、ガンモデルのゲームオブジェクトはリジッドボディがアタッチされてあり、子オブジェクトして複数のプリミティブなコライダを含みます。親のリジッドボディが力により動かされた場合、子コライダが追従して動きます。プリミティブなコライダは環境上にあるMesh Colliderと衝突し、親リジッドボディは自身に加えられた力の作用、子コライダがシーン上他のコライダとの衝突した作用、の双方を加味して軌道が変化します。

Mesh Collider同士は通常では衝突しませんが、Convexをオンにした場合のみ衝突することが出来ます。良くある方法として、動く全てのオブジェクトにはプリミティブなコライダを組み合わせ、動かない背景のオブジェクトにMesh Colliderを使います。

ヒント

• 複数のコライダをオブジェクトに追加するためには、子ゲームオブジェクトを作成し、コライダを各々にアタッチします。この方法でコライダは独立して動作させることが出来ます。
• シーンビューのギズモをみることでオブジェクトとコライダの大きさを確かめることができます
• コライダはオブジェクトと大きさを出来るかぎりマッチさせるのが良いです。均等でない大きさ（各々の軸方向での大きさが異なる）の場合、メッシュコライダでないかぎりオブジェクトと完全にマッチさせることは出来ません
• トランスフォームコンポーネントを通してオブジェクトを移動させつつ、衝突、トリガーのメッセージを受け取るためには動いているオブジェクトにリジッドボディをアタッチする必要があります。
• 爆発を作成したい場合、リジッドボディが衝突する壁から若干押し出すためには、何度もドラッグして、リジッドボディと球体コライダをそこに追加すると非常に有効な場合があります。

応用

コライダの組み合わせ

Unity上で複数の異なる衝突の組み合わせがありえる。それぞれのゲームで追求する内容は異なるので、ゲームのタイプによって組み合わせの良し悪しが決まってくる。ゲームで物理挙動を使用している場合、基本的なコライダの種類を理解し、主な働き、使用例、他のオブジェクトとの相互作用について理解を深める必要がある。

スタティックコライダ

リジッドボディを含まないが、コライダを含むゲームオブジェクトについて考えます。これらのオブジェクトは動かない、あるいは動くとしてもわずかであることが望ましいです。これらは背景のオブジェクトとして最適である。リジッドボディと衝突したとしても動きません。

リジッドボディコライダ

リジッドボディとコライダ双方を含むゲームオブジェクトについて考えます。これらのオブジェクトは物理エンジンに影響を受け、加えられた力や衝突によって軌道が変化します。またコライダを含むゲームオブジェクトと衝突させることが出来ます。多くの場合は物理エンジンを使用したい場合の主要なコライダとなります。

キネマティック　リジッドボディコライダ

IsKinematicがオンとなっているリジッドボディとコライダ双方を含みゲームオブジェクトについて考えます。このオブジェクトを動かすためには力を加えるのではなくトランスフォーム コンポーネントの値を書き換えて移動させます。スタティックコライダを共通点が多いがコライダを頻繁に動かしたい場合に役立ちます。その他、このオブジェクトを使用するのが適切なシナリオはいくつか考えられます。

このオブジェクトはスタティックコライダにトリガーイベントを発行したい場合に役立つ。トリガーはリジッドボディを含む必要があるためリジッドボディをアタッチしたうえでIsKinematicをオンに設定する。これによりオブジェクトが物理挙動の影響を受けず、必要なときにトリガーイベントを受け取ることが出来るようになる。

キネマティック　リジッドボディは簡単にオンオフを切り替えることが出来る。これはラグドール作成に大いに役立ち、たとえばキャクラターがある場面まではアニメーションどおりに動作し、その後に衝突によって爆発や何らかのエフェクトを起こしその後はラグドールの動作をさせたい場合に役立つ。

リジッドボディを長時間動かさない場合、完全にスリープ状態とさせることができる。言い換えると物理挙動のアップデート処理のなかで値が更新されることはなく、位置もそのままとなる。キネマティックリジッドボディコライダを通常のリジッドボディコライダの外に移動する場合、スリープ状態は解除され物理挙動のアップデート処理が再び始まる。つまり動かしたいスタティックコライダが複数あり、その上に異なるオブジェクトを落としたい場合にはキネマティック　リジッドボディコライダを使用すべきである。

衝突アクションマトリクス

衝突する2つのオブジェクトの設定によっては同時に複数のアクションが走る可能性がある。以下のチャートにより二つのオブジェクトが衝突する際の動作をアタッチされているコンポーネント等を基準に整理しました。いくつかの組み合わせにおいては片方のオブジェクトのみ衝突の影響を受けるので、原則として「オブジェクトにリジッドボディがなければ物理挙動もない」ということをよく頭に入れておく必要がある。

Layer-Based Collision Detection

Unity3.XではLayer-Based Collision Detectionが機能として追加されましたので、すべてのレイヤーの組み合わせにおいて、どのレイヤーの組み合わせでは衝突が発生するかオブジェクトに設定を行うことができます。詳細情報についてはここ をクリックし参照のこと。

ボックスコライダ

ボックスコライダは箱の型をした基本型コリジョンプリミティブです。

山積みされたボックスコライダ

プロパティ

詳細

ボックスコライダは様々な形の直方体に変形することが出来ます。ドア、壁、床、等々に最適です。さらにラグドールの胴体や車など乗り物の車体でも効果的です。言うまでもなく簡単な箱や壷にもピッタリです。

標準的なボックスコライダ

コライダはリジッドボディ（剛体）と連動してUnity上での物理挙動を実現します。リジッドボディというのは「オブジェクトを物理法則にしたがって動かす」一方で、コライダはオブジェクトが互いに衝突することを可能に｣します。コライダはリッジトボディとは別にオブジェクトにアタッチする必要があります。コライダとリジットボディは両方アタッチされなくとも良いですが、コリジョンの結果オブジェクトを動かすためにはリジッドボディがアタッチされていることは必須です。

二つのコライダ間で衝突が発生し、かつ少なくとも一つのオブジェクトにリジッドボディがアタッチされている場合、 3種類の 衝突 メッセージが 発行されます。これらのイベントはスクリプト作成時にハンドリングすることが出来ますし、独自のビヘイビアを定義することが出来るようになるとともにビルトインのNVIDIA PhysXエンジンを使用するかしないか自由に決めることができます。

トリガー

コライダをトリガーとしてマーキングする別の方法としてインスペクタでIsTrigger属性をチェックボックスにてオンするという方法があります。これによりトリガーは物理エンジンから無視されるようになり、コライダの衝突が発生した場合3種類の トリガー メッセージが 発行されます。トリガーはゲームにおける別イベントを発動するに際して便利です（カットシーンやドアの自動開閉、チュートリアルメッセージの表示、等々。想像を働かせれば様々なパターンで応用できます）

留意しないといけないこととして、二つのトリガーがトリガーイベント衝突時にを発行するためには、片方のトリガーはリジッドボディを含む必要があります。同様にトリガーが通常のコライダと衝突するためには片方のトリガーがリジッドボディを含む必要があります。全てのコライダ種類の一覧についていは図表にまとめてありますので、本項の「応用」セクションの「衝突アクションマトリクス」を参照下さい。

摩擦係数と反射係数

摩擦係数（friction）、反射係数（bouncyness）、やわらかさ（softness）は 物理マテリアル の属性として定義されています。スタンダードアセット のなかに頻繁に使用される物理マテリアルが含まれています。使用する際はPhysic Materialドロップダウンボックスをクリックし、どれかを選択します（例 Ice）。物理マテリアル については自分でカスタムのものを作成することができ、摩擦係数などすべて調整することが出来ます。

Mesh Collider

Mesh Colliderはメッシュアセット を取り、そのメッシュに基づいてコライダを構築します。複雑なメッシュの場合、プリミティブを使用した衝突検出するよりも遥かに正確です。ConvexがオンとなっているMesh Colliderは、他のMesh Colliderと衝突することができます。

階段状の物体で使用される'Mesh Collider

プロパティ

詳細

MeshColliderの衝突判定は形状をゲームオブジェクトにアタッチされたMesh から構築されており、アタッチされたTransform のプロパティを読み込んでPositionとScaleを正しく設定します。

衝突メッシュは、バックフェースカリングを使用しています。オブジェクトが表示上バックフェースカリングされたメッシュと衝突した場合、物理的に衝突することもありません。

MeshColliderを使用した場合、いくつかの制限があります。通常、2つのMeshColliderは互いに衝突することができません。すべてのMeshColliderはどのようなプリミティブコライダと衝突することができます。メッシュのConvexがオンの場合、他のMeshColliderと衝突することができます。

コライダはリジッドボディ（剛体）と連動してUnity上での物理挙動を実現します。リジッドボディというのは「オブジェクトを物理法則にしたがって動かす」一方で、コライダはオブジェクトが互いに衝突することを可能に｣します。コライダはリッジトボディとは別にオブジェクトにアタッチする必要があります。コライダとリジットボディは両方アタッチされなくとも良いですが、コリジョンの結果オブジェクトを動かすためにはリジッドボディがアタッチされていることは必須です。

二つのコライダ間で衝突が発生し、かつ少なくとも一つのオブジェクトにリジッドボディがアタッチされている場合、 3種類の 衝突 メッセージが 発行されます。これらのイベントはスクリプト作成時にハンドリングすることが出来ますし、独自のビヘイビアを定義することが出来るようになるとともにビルトインのNVIDIA PhysXエンジンを使用するかしないか自由に決めることができます。

トリガー

コライダをトリガーとしてマーキングする別の方法としてインスペクタでIsTrigger属性をチェックボックスにてオンするという方法があります。これによりトリガーは物理エンジンから無視されるようになり、コライダの衝突が発生した場合3種類の トリガー メッセージが 発行されます。トリガーはゲームにおける別イベントを発動するに際して便利です（カットシーンやドアの自動開閉、チュートリアルメッセージの表示、等々。想像を働かせれば様々なパターンで応用できます）

留意しないといけないこととして、二つのトリガーがトリガーイベント衝突時にを発行するためには、片方のトリガーはリジッドボディを含む必要があります。同様にトリガーが通常のコライダと衝突するためには片方のトリガーがリジッドボディを含む必要があります。全てのコライダ種類の一覧についていは図表にまとめてありますので、本項の「応用」セクションの「衝突アクションマトリクス」を参照下さい。

摩擦係数と反射係数

摩擦係数（friction）、反射係数（bouncyness）、やわらかさ（softness）は 物理マテリアル の属性として定義されています。スタンダードアセット のなかに頻繁に使用される物理マテリアルが含まれています。使用する際はPhysic Materialドロップダウンボックスをクリックし、どれかを選択します（例 Ice）。物理マテリアル については自分でカスタムのものを作成することができ、摩擦係数などすべて調整することが出来ます。

ヒント

• Convexがオンとなっていない限り、Mesh Colliderは、他のMesh Colliderと互いに衝突することができません。したがって、背景における物体のような背景のオブジェクトにも有用である。
• ConvexオンのMeshColliderは三角形面数の上限255です。
• 物理挙動のあるオブジェクトにおいて、プリミティブなコライダのほうがより計算コストがかからない。
• GameObjectにMesh Colliderをアタッチした場合、ゲームオブジェクトのレンダリングに使用されているメッシュがMeshプロパティにデフォルト設定される。異なるメッシュを割り当てれば、変更することができます。
• 複数のコライダをオブジェクトに追加するためには、子ゲームオブジェクトを作成し、コライダを各々にアタッチします。この方法でコライダは独立して動作させることが出来ます。
• シーンビューのギズモをみることでオブジェクトとコライダの大きさを確かめることができます
• コライダはオブジェクトと大きさを出来るかぎりマッチさせるのが良いです。均等でない大きさ（各々の軸方向での大きさが異なる）の場合、メッシュコライダでないかぎりオブジェクトと完全にマッチさせることは出来ません
• トランスフォームコンポーネントを通してオブジェクトを移動させつつ、衝突、トリガーのメッセージを受け取るためには動いているオブジェクトにリジッドボディをアタッチする必要があります。

物理特性マテリアル

Physic Material を使用して、衝突するオブジェクトの摩擦や跳ね返り効果を調整できます。

物理特性マテリアルを作成するには、メニューバーから Assets->Create->Physic Material を選択します。 次に、シーン内の Collider にプロジェクト ビューから物理特性マテリアルをドラッグします。

物理特性マテリアル Inspector'

プロパティ

詳細

摩擦は、面が互いに外れるのを防ぐ量です。 この値は、オブジェクトを重ねる時に重要です。 摩擦には動的と静的の 2 種類があります。 Static frictionは、オブジェクトが静止している際に使用されます。 これは、オブジェクトが動き始めるのを防ぎます。 強い力が加えられると、オブジェうとは動き始めます。 動き始めると、Dynamic Frictionが作用し始めます。 オブジェクトが別のオブジェクトと接触中に、Dynamic Frictionはオブジェクトを減速させようとします。

ヒント

• メイン キャラクターには、標準の物理特性マテリアルを使用しないでください。 カスタマイズしたマテリアルを使用して、より完璧なキャラクターを実現してください。

ヒンジ ジョイント

Hinge Joint は、2 つの Rigidbodies をグループ化し、互いにヒンジで連結されているかのように動くよう制約します。 ドアに最適ですが、鎖や振り子などをモデル化するのにも使用できます。

ヒンジ ジョイント Inspector'

プロパティ

詳細

1 つのヒンジを GameObject に適用する必要があります。 このヒンジは、Anchorプロパティで指定した点で回転し、指定したAxisプロパティ周辺で移動します。 ジョイントのConnected BodyプロパティにGameObject を割り当てる必要はありません。 ジョイントの Transform を追加したオブジェクトのトランスフォームに依存させたい場合にのみ、GameObject をConnected Bodyプロパティに割り当てる必要があります。

ドアのヒンジがどのように機能するかを考えましょう。 この場合のAxisは上で、Y 軸に沿って正になります。 Anchorは、ドアと壁の間の交差部のどこかに置かれます。 ジョイントは、デフォルトでワールドに連結されるので、壁をConnected Bodyに割当てる必要はありません。

次は、ドギー ドアのヒンジについて考えましょう。 ドギー ドアのAxisは横で、相対的な X 軸に沿って正になります。 メイン ドアをConnected Bodyに割当てる必要があるため、ドギー ドアのヒンジは、メイン ドアのリジッドボディに依存します。

鎖

複数のヒンジ ジョイントを連結して、鎖を作成することも出来ます。 鎖の各連結部分にジョイントを追加して、次の連結部をConnected Bodyとして追加します。

ヒント

• Connected Bodyが機能するよう、ジョイントに割り当てる必要はありません。
• 動的なダメージ システムを作成するには、Break Forceを使用します。 プレイヤーが、ロケット ランチャーで爆破する、あるいは車で突っ込んで、ドアとヒンジを切り離すことができるので非常に便利です。
• Spring、MotorおよびLimitsプロパティにより、ジョイントの動作を微調整できます。

スプリング ジョイント

Spring Joint は、2 つの Rigidbody をグループ化し、スプリングで連結されているかのように動くよう制約します。

スプリング ジョイント Inspector

プロパティ

詳細

スプリング ジョイントにより、剛体 GameObject は特定の目標：位置に引っ張られます。 この位置は、別のリジッド ボディの GameObject か世界のいずれかになります。 GameObject がこの目標位置から更に離れると、スプリング ジョイントがその元の目標''位置に引き戻す力を加えます。 これにより、ボムバンドやパチンコに非常に似た効果を作成できます。

スプリングの目標位置は、スプリング ジョイントを作成するか、再生モードに入った時に、AnchorからConnected Body(または世界)までの相対位置によって決定されます。 これにより、ジョイントしたキャラクターまたはオブジェクトをエディタで設定する際ににスプリング ジョイントが効率的になりますが、スプリングのプッシュ / プル 動作をスクリプティングを通じて、ランタイムで作成するのがより難しくなります。 スプリング ジョイントを使用して、主に GameObject の位置を変更したい場合、リジッドボディで空の GameObject を作成し、それをジョイントされたオブジェクトのConnected Rigidbodyに設定します。 次にスクリプティングで、Connected Rigidbodyの位置を変更でき、期待通りにスプリングが移動します。

Connected Rigidbody

• ジョイントを起動させるのに、Connected Bodyがを使用する必要はありません。 一般に、オブジェクトの位置および / または回転が依存していない場合のみに使用する必要があります。 Connected Rigidbodyがない場合は、スプリングはワールドに接続します。

スプリングとダンパー

スプリングは、オブジェクトをその目的の位置に引っ張り戻す力の強さです。 0 の場合、オブジェクトに引っ張る力はかからず、スプリング ジョイントがかからないかのよう動作します。

Damperは、Springの力に対する抵抗力です。 この値が低いほど、オブジェクトのスプリング力は強くなります。 Damperが増えると、ジョイントによる跳ね返りの量は減ります。

Min & Max Distance

オブジェクトの位置がMinとMax Distances間にある場合、ジョイントはオブジェクトに適用されません。 この位置を、有効にするジョイントに対して、これらの値外に移動させる必要があります。

ヒント

• ジョイントが機能するよう、Connected Bodyをジョイントに割り当てる必要はありません。
• 再生モードに入る前に、エディタでジョイント オブジェクトの理想的な位置を設定します。
• スプリング ジョイントは、リジッドボディを追加する必要があります。

iOS

RandomNumbers

Randomly chosen items or values are important in many games. This sections shows how you can use Unity's built-in random functions to implement some common game mechanics.

Choosing a Random Item from an Array

Picking an array element at random boils down to choosing a random integer between zero and the array's maximum index value (which is equal to the length of the array minus one). This is easily done using the built-in Random.Range function:-

var element = myArray[Random.Range(0, myArray.Length)];

Note that Random.Range returns a value from a range that includes the first parameter but excludes the second, so using myArray.Length here gives the correct result.

Choosing Items with Different Probabilities

Sometimes, you need to choose items at random but with some items more likely to be chosen than others. For example, an NPC may react in several different ways when it encounters a player:-

• 50% chance of friendly greeting
• 25% chance of running away
• 20% chance of immediate attack
• 5% chance of offering money as a gift

You can visualise these different outcomes as a paper strip divided into sections each of which occupies a fraction of the strip's total length. The fraction occupied is equal to the probability of that outcome being chosen. Making the choice is equivalent to picking a random point along the strip's length (say by throwing a dart) and then seeing which section it is in.

In the script, the paper strip is actually an array of floats that contain the different probabilities for the items in order. The random point is obtained by multiplying Random.value by the total of all the floats in the array (they need not add up to 1; the significant thing is the relative size of the different values). To find which array element the point is "in", firstly check to see if it is less than the value in the first element. If so, then the first element is the one selected. Otherwise, subtract the first element's value from the point value and compare that to the second element and so on until the correct element is found. In code, this would look something like the following:-

function Choose(probs: float[]) {
	var total = 0;

	for (elem in probs) {
		total += elem;
	}

	var randomPoint = Random.value * total;

	for (i = 0; i < probs.Length; i++) {
		if (randomPoint < probs[i])
			return i;
		else
			randomPoint -= probs[i];
	}

	return probs.Length - 1;
}

Note that the final return statement is necessary because Random.value can return a result of 1. In this case, the search will not find the random point anywhere. Changing the line

if (randomPoint < probs[i])

...to a less-than-or-equal test would avoid the extra return statement but would also allow an item to be chosen occasionally even when its probability is zero.

Shuffling a List

A common game mechanic is to choose from a known set of items but have them arrive in random order. For example, a deck of cards is typically shuffled so they are not drawn in a predictable sequence. You can shuffle the items in an array by visiting each element and swapping it with another element at a random index in the array:-

function Shuffle(deck: int[]) {
	for (i = 0; i < deck.Length; i++) {
		var temp = deck[i];
		var randomIndex = Random.Range(0, deck.Length);
		deck[i] = deck[randomIndex];
		deck[randomIndex] = temp;
	}
}

Choosing from a Set of Items Without Repetition

A common task is to pick a number of items randomly from a set without picking the same one more than once. For example, you may want to generate a number of NPCs at random spawn points but be sure that only one NPC gets generated at each point. This can be done by iterating through the items in sequence, making a random decision for each as to whether or not it gets added to the chosen set. As each item is visited, the probability of its being chosen is equal to the number of items still needed divided by the number still left to choose from.

As an example, suppose that ten spawn points are available but only five must be chosen. The probability of the first item being chosen will be 5 / 10 or 0.5. If it is chosen then the probability for the second item will be 4 / 9 or 0.44 (ie, four items still needed, nine left to choose from). However, if the first was not chosen then the probability for the second will be 5 / 9 or 0.56 (ie, five still needed, nine left to choose from). This continues until the set contains the five items required. You could accomplish this in code as follows:-

var spawnPoints: Transform[];

function ChooseSet(numRequired: int) {
	var result = new Transform[numRequired];

	var numToChoose = numRequired;

	for (numLeft = spawnPoints.Length; numLeft > 0; numLeft--) {
		// Adding 0.0 is simply to cast the integers to float for the division.
		var prob = numToChoose + 0.0 / numLeft + 0.0;

		if (Random.value <= prob) {
			numToChoose--;
			result[numToChoose] = spawnPoints[numLeft - 1];

			if (numToChoose == 0)
				break;
		}
	}

	return result;
}

Note that although the selection is random, items in the chosen set will be in the same order they had in the original array. If the items are to be used one at a time in sequence then the ordering can make them partly predictable, so it may be necessary to shuffle the array before use.

Random Points in Space

A random point in a cubic volume can be chosen by setting each component of a Vector3 to a value returned by Random.value:-

var randVec = Vector3(Random.value, Random.value, Random.value);

This gives a point inside a cube with sides one unit long. The cube can be scaled simply by multiplying the X, Y and Z components of the vector by the desired side lengths. If one of the axes is set to zero, the point will always lie within a single plane. For example, picking a random point on the "ground" is usually a matter of setting the X and Z components randomly and setting the Y component to zero.

When the volume is a sphere (ie, when you want a random point within a given radius from a point of origin), you can use Random.insideUnitSphere multiplied by the desired radius:-

var randWithinRadius = Random.insideUnitSphere * radius;

Note that if you set one of the resulting vector's components to zero, you will *not* get a correct random point within a circle. Although the point is indeed random and lies within the right radius, the probability is heavily biased toward the edge of the circle and so points will be spread very unevenly. You should use Random.insideUnitCircle for this task instead:-

var randWithinCircle = Random.insideUnitCircle * radius;

Particle Systems

注意：これは新パーティクルシステム（Shuriken）についてのドキュメントです。旧パーティクルシステムについては Legacy Particle System を参照して下さい。

パーティクルシステム（Shuriken）

Unityの中のパーティクルシステムは、大量の煙、蒸気、炎やその他の大気圏エフェクトを作るために使用されます。

新規にParticle Systemを作成するにはParticle Systemゲームオブジェクトを作成（メニューでGameObject -> Create Other -> Particle Systemを選択）するか、空のGameObjectを作成して ParticleSystemコンポーネントを追加します。（メニューでComponent->Effectsを選択）

The Particle System Inspector (Shuriken)

The Particle System Inspector shows one particle system at a time (the currently selected one), and it looks like this:

Individual particle systems can take on various complex behaviors by using Modules.

They can also be extended by being grouped together into Particle Effects.

If you press the button Open Editor ..., this will open up the Extended Particle Editor, that shows all of the particle systems under the same root in the scene tree. For more information on particle system grouping, see the section on Particle Effects.

シーンビューの編集

パーティクルシステムを作成および編集するときInspectorまたは拡張されたParticle Editorを使用し、その変更内容はSceneViewに反映されます。シーンビューにはPreview Panelがあり、現在選択したParticle Effectのプレイバックを編集モードで制御することが出来、アクションとしてplay、pause、stopおよびscrubbing playback timeが用意されています。

'Playback Time''ラベルをドラッグすることにより、プレイバック時間をこすって調整することができます。全てのプレイバックコントロールにはショートカットキーがあり、それらはPreferencesウィンドウ にてカスタム設定できます。

パーティクルシステムCurve Editor

MinMax Curve

パーティクルシステム　モジュールのプロパティの多くは時間の経過とともに値が変化します。そういう変更は MinMax Curves（最大最小カーブ）を通じて表現できます。 これらの時間により活性化するプロパティ（たとえばsize およびspeed）、は右側にプルダウンメニューがあり、それを選択することが出来ます。 Attach:MinMaxDropDown.png Δ

Constant: プロパティの値が時間とともに変化しないので、Curve Editorに表示されません。

Random between constants: プロパティの値は、2つの定数間のランダム値に設定されます。

Curve:プロパティの値が時間とともにCurve Editorのカーブに基づいて変化します。

カーブでアニメーションされたプロパティ

Random between curves: プロパティの値は、2つの最大、最小のカーブの間でランダムに設定され、値は時とともに生成されたカーブに基づいて変化します。

Random Between Two Curvesとして活性化されたプロパティ。

Curve Editorで0とDurationプロパティで指定した値の間で時間を"X"'軸上に散らせたうえで、"Y"軸は各々の時間における活性化されたプロパティの値を示します。 "Y"軸の範囲はCurve Editor右上隅にある数字フィールドで調整することができます。現時点で、Curve Editorはパーティクルシステムの全てのカーブを同じウィンドウで表示します。

同じCurve Editorで複数のカーブを表示。

なお、右下隅の" - "は現在選択されているカーブを削除する一方で"+"はそれを"最適化"します（これにより、高々3つのキーをもつパラメータ化されたカーブとなります）。

3D空間でのベクトルを表現する活性化されたプロパティにはTripleMinMaxカーブを用意していて、これは単にx軸、y軸、z軸を横に並べたシンプルなカーブであり、次のように表示されます：

Curve Editorで複数のカーブの管理

Curve Editorで混乱を防ぐためには、インスペクタでそクリックすることで、カーブのオンとオフに切り替えることが可能です。パーティクルシステムのCurve Editorを、あなたがこのようなものが表示されるはずです。その後Particle System Curvesタイトルバー上で右クリックして、インスペクタから切り離すことができます：

他のウィンドウと同様で、Curve Editorのウィンドウをドックすることが出来ます。

カーブの働きに関する情報については、Curve Editorドキュメンテーションを参照のこと。

パーティクルシステムの色およびグラデーション（Shuriken）

色を扱うプロパティについて、 Particle Systemは Color and Gradient Editor``を使用しています。 それはCurve Editor と同じような働きをします。

カラーベースのプロパティは右側にプルダウンメニューがあり、好きな方法を選択することが出来ます。

Color: 色は常に同じになります（Color Picker を参照してください）。

Gradient: グラデーション（RGBA）はGradient Editor で編集したとおりに、時間とともに変化します。

Random Between Two Colors: 色は時間とともに変化し、Color Picker で指定した二つの値の間でランダムに選択されます。

Random Between Two Gradients: グラデーション（RGBA）はGradient Editor で指定した二つの値の間でランダムに選択され、時間とともに変化します。

• パーティクルシステムCurve Editor
• パーティクルシステムの色およびグラデーション（Shuriken）
• Gradient Editor
• Particle System Inspector
• Introduction to Particle System Modules (Shuriken)
• Particle System Modules (Shuriken)
• Particle Effects (Shuriken)

Particle System Curve Editor

MinMax Curve

パーティクルシステム　モジュールのプロパティの多くは時間の経過とともに値が変化します。そういう変更は MinMax Curves（最大最小カーブ）を通じて表現できます。 これらの時間により活性化するプロパティ（たとえばsize およびspeed）、は右側にプルダウンメニューがあり、それを選択することが出来ます。 Attach:MinMaxDropDown.png Δ

Constant: プロパティの値が時間とともに変化しないので、Curve Editorに表示されません。

Random between constants: プロパティの値は、2つの定数間のランダム値に設定されます。

Curve:プロパティの値が時間とともにCurve Editorのカーブに基づいて変化します。

カーブでアニメーションされたプロパティ

Random between curves: プロパティの値は、2つの最大、最小のカーブの間でランダムに設定され、値は時とともに生成されたカーブに基づいて変化します。

Random Between Two Curvesとして活性化されたプロパティ。

Curve Editorで0とDurationプロパティで指定した値の間で時間を"X"'軸上に散らせたうえで、"Y"軸は各々の時間における活性化されたプロパティの値を示します。 "Y"軸の範囲はCurve Editor右上隅にある数字フィールドで調整することができます。現時点で、Curve Editorはパーティクルシステムの全てのカーブを同じウィンドウで表示します。

同じCurve Editorで複数のカーブを表示。

なお、右下隅の" - "は現在選択されているカーブを削除する一方で"+"はそれを"最適化"します（これにより、高々3つのキーをもつパラメータ化されたカーブとなります）。

3D空間でのベクトルを表現する活性化されたプロパティにはTripleMinMaxカーブを用意していて、これは単にx軸、y軸、z軸を横に並べたシンプルなカーブであり、次のように表示されます：

Curve Editorで複数のカーブの管理

Curve Editorで混乱を防ぐためには、インスペクタでそクリックすることで、カーブのオンとオフに切り替えることが可能です。パーティクルシステムのCurve Editorを、あなたがこのようなものが表示されるはずです。その後Particle System Curvesタイトルバー上で右クリックして、インスペクタから切り離すことができます：

他のウィンドウと同様で、Curve Editorのウィンドウをドックすることが出来ます。

カーブの働きに関する情報については、Curve Editorドキュメンテーションを参照のこと。

Particle System Color Editor

色を扱うプロパティについて、 Particle Systemは Color and Gradient Editor``を使用しています。 それはCurve Editor と同じような働きをします。

カラーベースのプロパティは右側にプルダウンメニューがあり、好きな方法を選択することが出来ます。

Color: 色は常に同じになります（Color Picker を参照してください）。

Gradient: グラデーション（RGBA）はGradient Editor で編集したとおりに、時間とともに変化します。

Random Between Two Colors: 色は時間とともに変化し、Color Picker で指定した二つの値の間でランダムに選択されます。

Random Between Two Gradients: グラデーション（RGBA）はGradient Editor で指定した二つの値の間でランダムに選択され、時間とともに変化します。

Particle System Gradient Editor

The Gradient Editor is used for describing change of gradient with time. It animates the color (RGB-space, described by the markers at the bottom), and Alpha (described by the markers at the top).

You can add new markers for Alpha values by clicking near the top of the rectangle, and new ticks for Color by clicking near the bottom. The markers can be intuitively dragged along the timeline.

If an Alpha tick is selected, you can edit the value for that tick by dragging the alpha value.

If a Color tick is selected, the color can be modified by double clicking on the tick or clicking on the color bar.

To remove a marker, just drag it off the screen.

Particle System Inspector

The Particle System Inspector (Shuriken)

The Particle System Inspector shows one particle system at a time (the currently selected one), and it looks like this:

Individual particle systems can take on various complex behaviors by using Modules.

They can also be extended by being grouped together into Particle Effects.

If you press the button Open Editor ..., this will open up the Extended Particle Editor, that shows all of the particle systems under the same root in the scene tree. For more information on particle system grouping, see the section on Particle Effects.

Particle System Modules Intro

A Particle System consists of a predefined set of modules that can be enabled and disabled. These modules describe the behavior of particles in an individual particle system.

Initially only a few modules are enabled. Addding or removing modules changes the behavior of the particle system. You can add new modules by pressing the (+) sign in the top-right corner of the Particle System Inspector. This pops up a selection menu, where you can choose the module you want to enable.

An alternative way to work with modules is to select "Show All Modules", at which point all of the modules will show up in the inspector.

Then you can enable / disable modules directly from the inspector by clicking the checkbox to the left.

Most of the properties are controllable by curves (see Curve Editor). Color properties are controlled via gradients which define an animation for color (see Color Editor).

For details on individual modules and their properties, see Particle System Modules

Particle System Modules40

This page is dedicated to individual modules and their properties. For introduction to modules see this page

Initial Module

This module is always present, cannot be removed or disabled.

Emission Module

Controls the rate of particles being emitted and allows spawning large groups of particles at certain moments (over Particle System duration time). Useful for explosions when a bunch of particles need to be created at once.

Shape Module

Defines the shape of the emitter: Sphere, Hemishpere, Cone, Box and Mesh. Can apply initial force along the surface normal or random direction.

Velocity Over Lifetime Module

Directly animates velocity of the particle. Mostly useful for particles which has complex physical, but simple visual behavior (like smoke with turbulence and temperature loss) and has little interaction with physical world.

Limit Velocity Over Lifetime Module

Basically can be used to simulate drag. Dampens or clamps velocity, if it is over certain threshold. Can be configured per axis or per vector length.

Force Over Lifetime Module

Color Over Lifetime Module

Color By Speed Module

Animates particle color based on its speed. Remaps speed in the defined range to a color.

Size Over Lifetime Module

Size By Speed Module

Rotation Over Lifetime Module

Specify values in degrees.

Rotation By Speed Module

External Forces Module

Collision Module

Set up collisions for the particles of this Particle System. World and planar collisions are supported. Planar collision is very efficient for simple collision detection. Planes are set up by referencing an existing transform in the scene or by creating a new empty GameObject for this purpose. Another benefit of planar collision is that particle systems with collision planes can be set up as prefabs. World collision uses raycasts so must be used with care in order to ensure good performance. However, for cases where approximate collisions are acceptable world collision in Low or Medium quality can be very efficient.

Properties common for any Collision Module

Properties available only in the Planes Mode

Properties available only in the World Mode

Sub Emitter Module

This is a powerful module that enables spawning of other Particle Systems at the follwing particle events: birth, death or collision of a particle.

Texture Sheet Animation Module

Animates UV coordinates of the particle over its lifetime. Animation frames can be presented in a form of a grid or every row in the sheet can be separate animation. The frames are animated with curves or can be a random frame between two curves. The speed of the animation is defined by "Cycles".

Renderer Module

The renderer module exposes the ParticleSystemRenderer component's properties. Note that even though a GameObject has a ParticleSystemRenderer component, its properties are only exposed here, when this module is removed/added. It is actually the ParticleSystemRenderer component that is added or removed.

Particle System Grouping

An important feature of Unity's Particle System is that individual Particle Systems can be grouped by being parented to the same root. We will use the term Paricle Effect for such a group. Particle Systems belonging to the same Particle Effect, are played, stopped and paused together.

For managing complex particle effects, Unity provides a Particle Editor, which can be accessed from the Inspector, by pressing Open Editor

Overview of the Particle System Editor

You can toggle between Show: All and Show: Selected in this Editor. Show: All will render the entire particle effect. Show: Selected will only render the selected particle systems. What is selected will be highlighted with a blue frame in the Particle Editor and also shown in blue in the Hierarchy view. You can also change the selection both from the Hierarchy View and the Particle Editor, by clicking the icon in the top-left corner of the Particle System. To do a multiselect, use Ctrl+click on windows and Command+click on the Mac.

You can explicitly control rendering order of grouped particles (or otherwise spatially close particle emitters) by tweaking Sorting Fudge property in the Renderer module.

Particle Systems in the same hierarchy are considered as part of the same Particle Effect. This hierarchy shows the setup of the effect shown above.

Mecanim Animation System

Unity has a rich and sophisticated animation system called Mecanim. Mecanim provides:

• Easy workflow and setup of animations on humanoid characters.
• Animation retargeting - the ability to apply animations from one character model onto another.
• Simplified workflow for aligning animation clips.
• Convenient preview of animation clips, transitions and interactions between them. This allows animators to work more independently of programmers, prototype and preview their animations before gameplay code is hooked in.
• Management of complex interactions between animations with a visual programming tool.
• Animating different body parts with different logic.

Mecanim workflow

Workflow in Mecanim can be split into three major stages.

1. Asset preparation and import. This is done by artists or animators, with 3rd party tools, such as Max or Maya. This step is independent of Mecanim features.
2. Character setup for Mecanim, which can be done in 2 ways:

   a. Humanoid character setup. Mecanim has a special workflow for humanoid models, with extended GUI support and retargeting. The setup involves creating and setting up an Avatar and tweaking Muscle definitions.
   b. Generic character setup. This is for anything like creatures, animated props, four-legged animals, etc. Retargeting is not possible here, but you can still take advantage of the rich feature set of Mecanim, including everything described below. 

3. Bringing characters to life. This involves setting up animation clips, as well as interactions between them, and involves setup of State Machines and Blend Trees, exposing Animation Parameters, and controlling animations from code.

Mecanim comes with a lot of new concepts and terminology. If at any point, you need to find out what something means, go to our Animation Glossary.

• A Glossary of Animation and Mecanim terms
• Asset Preparation and Import
  • Preparing your own character
  • Importing Animations
  • Splitting Animations
• Working with humanoid animations
  • Avatar作成
  • Configuring the Avatar
  • Muscle setup
  • Avatar Body Mask
  • Retargeting of Humanoid animations
  • Inverse Kinematics (Pro only)
• Generic Animations in Mecanim
• Bringing characters to life
  • Looping animation clips
  • Animator Component and Animator Controller
  • Animation State Machines
    • Animation States
    • Animation Transitions
    • Animation Parameters
  • Blend Trees
  • Mecanim Advanced topics:
    • Working with Animation Curves in Mecanim (Pro only)
    • Nested State Machines
    • Animation Layers
    • Animation State Machine Preview (solo and mute)
    • Target Matching
    • Root Motion - how it works
      • Manually Scripting Root Motion